LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
testb $0x4, %sil
je 0x41328
leaq 0xd724(%rip), %rsi      # 0x4ea34
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xe2f0
movq %r12, %rdi
callq 0x41372
testq %r15, %r15
je 0x41348
leaq 0xd70c(%rip), %rsi      # 0x4ea40
movq %rsp, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xe2f0
jmp 0x4135e
leaq 0xd703(%rip), %rsi      # 0x4ea52
movq %rsp, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe2f0
movq %rsp, %rdi
callq 0x41372
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5563c(%rip), %r12     # 0x969c0
callq 0xe0f0
movq %rax, %r15
leal 0x21(%rax), %esi
movl $0x1, %edi
callq 0xe1e0
testq %rax, %rax
je 0x413ee
movq %rax, %rbx
leal 0x1(%r15), %edx
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rax)
movq %r14, %rsi
callq 0xe210
movl %r15d, (%rbx)
movq %rbx, %rax
testq %r12, %r12
je 0x413d3
movq 0x18(%r12), %rax
movq %rax, 0x18(%rbx)
movq %rbx, 0x10(%rax)
movq %r12, %rax
movq %rbx, 0x18(%rax)
movq %rax, 0x10(%rbx)
movq %rax, 0x555de(%rip)     # 0x969c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xd66b(%rip), %rdi      # 0x4ea60
xorl %eax, %eax
callq 0x11dc6
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x555cd(%rip), %rsi     # 0x969d0
cmpq %rdi, %rsi
je 0x41436
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4141d
movq %rbx, %rdi
callq 0xe1f0
testl %eax, %eax
je 0x41435
leaq 0x7145(%rip), %rdi      # 0x48569
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe110
movq %rbx, 0x5559b(%rip)     # 0x969d0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x414f3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x414d7
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x41472
testq %rbp, %rbp
je 0x414c8
movq 0xb0(%rbp), %rdi
movq 0xd0(%rbp), %r14
testq %rdi, %rdi
je 0x4148c
callq 0x40caf
jmp 0x4149f
movl 0x50(%rbp), %eax
leal 0x7(%rax), %edi
testl %eax, %eax
cmovnsl %eax, %edi
sarl $0x3, %edi
callq 0x41736
movq %rax, %r15
testq %r14, %r14
jne 0x414c0
movl $0x1, %edi
movl $0x8, %esi
callq 0xe1e0
movq %rax, %r14
movq %rax, 0xd0(%rbp)
movq %r15, (%r14)
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x4145d
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x41451
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/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 %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0x30, %esi
callq 0xe1e0
testq %rax, %rax
je 0x4150f
movl %ebx, (%rax)
popq %rbx
retq
leaq 0xd93c(%rip), %rdi      # 0x4ee52
xorl %eax, %eax
callq 0x11dc6
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rbp
movq 0x5549d(%rip), %r14     # 0x969d8
movl $0x1, %edi
callq 0x41a4e
testq %rbp, %rbp
je 0x4159e
movq %rax, %r13
leaq 0x8(%rax), %rdi
movq %rbp, %rsi
callq 0xe0a0
testq %r12, %r12
je 0x41579
cmpb $0x0, (%r12)
je 0x41579
movq %r13, %rdi
addq $0x28, %rdi
movl $0x27, %edx
movq %r12, %rsi
callq 0xe080
movq %r15, 0x50(%r13)
movq %rbx, 0x58(%r13)
addq $0x10, %r14
movq %r14, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c714
leaq 0xd8c0(%rip), %rdi      # 0x4ee65
leaq 0xd420(%rip), %rsi      # 0x4e9cc
leaq 0xd8bf(%rip), %rcx      # 0x4ee72
movl $0x277, %edx            # imm = 0x277
callq 0xe140
// File: /workspace/github_c_makefile_star2_O3/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:
addl $-0x8, %esi
roll $0x1d, %esi
cmpl $0x8, %esi
jae 0x41730
movl $0x8b, %eax
btl %esi, %eax
jae 0x41730
movq %rdi, %rdx
movl %esi, %eax
leaq 0xdbcc(%rip), %rcx      # 0x4f2e4
movl (%rcx,%rax,4), %ecx
leaq 0x552ce(%rip), %rdi     # 0x969f0
leaq 0xd4dc(%rip), %rsi      # 0x4ec05
xorl %eax, %eax
jmp 0xe2f0
pushq %rax
callq 0xe060
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq 0x55297(%rip), %rbx     # 0x969d8
testq %rbx, %rbx
je 0x41789
movl %edi, %ebp
xorl %edi, %edi
callq 0x414f4
movq %rax, %r14
movl $0x0, (%rax)
movl 0x4(%rbx), %eax
movl %eax, 0x20(%r14)
movl (%rbx), %ecx
movl %ecx, 0x24(%r14)
movl %ebp, 0x28(%r14)
addl %ebp, %ecx
movl %ecx, (%rbx)
incl %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c714
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd4f1(%rip), %rdi      # 0x4ec81
leaq 0xd235(%rip), %rsi      # 0x4e9cc
leaq 0xd4ed(%rip), %rcx      # 0x4ec8b
movl $0x20e, %edx            # imm = 0x20E
callq 0xe140
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0xd500(%rip), %rdi      # 0x4ecb3
xorl %eax, %eax
callq 0x4189d
leaq 0x28607(%rip), %rsi     # 0x69dc8
movq %rbx, %rdi
callq 0x41958
movq %rax, %rbx
leaq 0xd4f5(%rip), %rdi      # 0x4ecc8
movq %rax, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x4151d
movq 0x10(%rbx), %rax
movl 0x10(%rax), %edi
callq 0x419d9
movl 0x551ee(%rip), %ebx     # 0x969e0
incl %ebx
movl %ebx, 0x551e6(%rip)     # 0x969e0
movl $0x5, %edi
callq 0x414f4
movl %ebx, 0x20(%rax)
movq $0x2, 0x8(%rax)
leaq 0xd4b7(%rip), %rdi      # 0x4eccd
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4151d
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edi, %ebp
movl 0x551a8(%rip), %ebx     # 0x969e0
incl %ebx
movl %ebx, 0x551a0(%rip)     # 0x969e0
movl $0x5, %edi
callq 0x414f4
movl %ebx, 0x20(%rax)
movq $0x2, 0x8(%rax)
leaq 0x810d(%rip), %rdi      # 0x49969
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4151d
movq 0x55169(%rip), %r14     # 0x969d8
leaq 0x6809(%rip), %rsi      # 0x4807f
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe2f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0d
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0xd0, %rsp
movq %rdi, %r10
testb %al, %al
je 0x418e3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %rax
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r8, 0x20(%rax)
movq %r9, 0x28(%rax)
movq 0x550d5(%rip), %rbx     # 0x969d8
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x28439(%rip), %rdi     # 0x69d63
movl $0x60, %esi
movq %r10, %rdx
callq 0xe0c0
leaq 0x28422(%rip), %rsi     # 0x69d60
cltq
movw $0xa, 0x3(%rax,%rsi)
movq %rbx, %rdi
callq 0x41a0d
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x4196e
cmpq %rbx, 0x8(%r14)
je 0x4199d
movq %rsi, %rdi
callq 0x41af8
movq %rax, %r14
movq 0x18(%rbx), %rdx
leaq 0xd371(%rip), %rcx      # 0x4ecf5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x415bd
movq 0x10(%r14), %rax
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%rbx)
jmp 0x419ce
movq (%r14), %rsi
leaq 0xd335(%rip), %rdi      # 0x4ecdc
xorl %eax, %eax
callq 0x4189d
movzbl 0x10(%r14), %eax
leaq (%rax,%rax,2), %rax
shll $0x4, %eax
leaq 0x27adf(%rip), %r14     # 0x694a0
addq %rax, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x41a77
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/./bitmap.h
// Function: put_reg
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:
movl %edi, %eax
shrl $0x3, %eax
andl $0x18, %eax
leaq 0x55028(%rip), %rcx     # 0x96a10
movq (%rax,%rcx), %rdx
movq %rdx, %rsi
btrq %rdi, %rsi
movq %rsi, (%rax,%rcx)
btq %rdi, %rdx
jae 0x419fe
retq
pushq %rax
movzbl %dil, %edi
callq 0xe8fa
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x41a4e
movq %rax, %r15
movq %rbx, %rdi
callq 0xe310
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0xe0f0
movl %eax, 0x10(%r15)
addq $0x10, %r14
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1c714
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0x60, %esi
callq 0xe1e0
testq %rax, %rax
je 0x41a69
movl %ebx, (%rax)
popq %rbx
retq
leaq 0xd260(%rip), %rdi      # 0x4ecd0
xorl %eax, %eax
callq 0x11dc6
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x10(%rdi), %rax
movb 0x10(%rax), %cl
testb %cl, %cl
je 0x41ad0
leaq 0x11(%rax), %rdx
leaq 0x54f82(%rip), %r8      # 0x96a10
leaq 0x27f4b(%rip), %r9      # 0x699e0
movzbl %cl, %ecx
movl %ecx, %r10d
shrb $0x3, %r10b
movzbl %r10b, %r10d
andl $0x18, %r10d
movq (%r10,%r8), %r10
btq %rcx, %r10
jb 0x41aed
testl %esi, %esi
je 0x41ac1
shll $0x5, %ecx
movq $0x0, 0x8(%rcx,%r9)
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x41a95
movzbl 0x10(%rax), %ecx
jmp 0x41ad2
xorl %ecx, %ecx
movl $0x1, %eax
shlq %cl, %rax
shrl $0x6, %ecx
leaq 0x54f2c(%rip), %rdx     # 0x96a10
orq %rax, (%rdx,%rcx,8)
movq %rdi, %rax
popq %rcx
retq
movq %rax, %rdi
movq %rcx, %rsi
callq 0xe924
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movb 0x8(%rdi), %sil
testb %sil, %sil
je 0x41b67
leaq 0x8(%rdi), %rax
leaq 0x54f03(%rip), %rcx     # 0x96a10
leaq 0x27ecc(%rip), %rdx     # 0x699e0
movzbl %sil, %esi
movl %esi, %r8d
shrb $0x3, %r8b
movzbl %r8b, %r8d
andl $0x18, %r8d
movq (%r8,%rcx), %r8
btq %rsi, %r8
jb 0x41b5c
movl %esi, %r8d
shll $0x5, %r8d
addq %rdx, %r8
addq $0x11, %r8
movzbl (%r8), %r9d
testq %r9, %r9
je 0x41b6c
incq %r8
movl %r9d, %r10d
shrl $0x6, %r10d
movq (%rcx,%r10,8), %r10
btq %r9, %r10
jae 0x41b3f
incq %rax
movb (%rax), %sil
testb %sil, %sil
jne 0x41b14
callq 0xe979
leaq (%rsi,%rsi,2), %rax
shll $0x4, %eax
leaq 0x27926(%rip), %rdi     # 0x694a0
addq %rax, %rdi
movl $0x1, %esi
popq %rax
jmp 0x41a77
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: stor_op_name
static const char *stor_op_name(struct storage *s)
{
	static char name[32];

	switch (s->type) {
	case STOR_PSEUDO:
		strcpy(name, pretty_offset((int) pseudo_offset(s)));
		break;
	case STOR_ARG:
		strcpy(name, pretty_offset((int) arg_offset(s)));
		break;
	case STOR_SYM:
		strcpy(name, show_ident(s->sym->ident));
		break;
	case STOR_REG:
		strcpy(name, s->reg->name);
		break;
	case STOR_VALUE:
		sprintf(name, "$%lld", s->value);
		break;
	case STOR_LABEL:
		sprintf(name, "%s.L%d", s->flags & STOR_LABEL_VAL ? "$" : "",
			s->label);
		break;
	case STOR_LABELSYM:
		sprintf(name, "%s.LS%p", s->flags & STOR_LABEL_VAL ? "$" : "",
			s->labelsym);
		break;
	}

	return name;
}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x41c01
leaq 0xcd88(%rip), %rcx      # 0x4e920
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x24(%rdi), %edx
testl %edx, %edx
jne 0x41c17
movl $0x297073, 0x55681(%rip) # imm = 0x297073
movl $0x73652528, 0x55674(%rip) # imm = 0x73652528
jmp 0x41c2c
movq 0x20(%rdi), %rdx
leaq 0x55647(%rip), %rdi     # 0x97210
leaq 0xb032(%rip), %rsi      # 0x4cc02
xorl %eax, %eax
popq %rcx
jmp 0xe2f0
movq 0x20(%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x21ba5
leaq 0x55624(%rip), %rdi     # 0x97210
movq %rax, %rsi
jmp 0x41c3a
movq 0x10(%rdi), %rax
movq (%rax), %rsi
leaq 0x55611(%rip), %rdi     # 0x97210
jmp 0x41c3a
popq %rax
retq
movq 0x54dce(%rip), %rax     # 0x969d8
movl 0x20(%rdi), %edx
shll $0x2, %edx
addl (%rax), %edx
addl $0x4, %edx
je 0x41ba8
leaq 0x55612(%rip), %rdi     # 0x97230
leaq 0xd375(%rip), %rsi      # 0x4ef9a
xorl %eax, %eax
callq 0xe2f0
leaq 0x555dd(%rip), %rdi     # 0x97210
leaq 0x555f6(%rip), %rsi     # 0x97230
popq %rax
jmp 0xe0a0
testb $0x1, 0x8(%rdi)
leaq 0x1c82(%rip), %rax      # 0x438cd
leaq 0xd33e(%rip), %rdx      # 0x4ef90
cmoveq %rax, %rdx
movl 0x20(%rdi), %ecx
leaq 0x555b0(%rip), %rdi     # 0x97210
leaq 0xd322(%rip), %rsi      # 0x4ef89
xorl %eax, %eax
popq %r8
jmp 0xe2f0
testb $0x1, 0x8(%rdi)
leaq 0x1c52(%rip), %rax      # 0x438cd
leaq 0xd30e(%rip), %rdx      # 0x4ef90
cmoveq %rax, %rdx
movq 0x20(%rdi), %rcx
leaq 0x5557f(%rip), %rdi     # 0x97210
leaq 0xd2fa(%rip), %rsi      # 0x4ef92
xorl %eax, %eax
popq %r8
jmp 0xe2f0
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_assignment
static struct storage *x86_assignment(struct expression *expr)
{
	struct expression *target = expr->left;
	struct storage *val, *addr;

	if (!expr->ctype)
		return NULL;

	val = x86_expression(expr->right);
	addr = x86_address_gen(target);

	switch (val->type) {
	/* copy, where both operands are memory */
	case STOR_PSEUDO:
	case STOR_ARG:
		emit_copy(addr, val, expr->ctype);
		break;

	/* copy, one or zero operands are memory */
	case STOR_REG:
	case STOR_SYM:
	case STOR_VALUE:
	case STOR_LABEL:
		emit_move(val, addr, expr->left->ctype, NULL);
		break;

	case STOR_LABELSYM:
		assert(0);
		break;
	}
	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x41ebf
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %rdi
callq 0x40caf
movq %rax, %rbx
movq %r15, %rdi
callq 0x42797
movl (%rbx), %ecx
leal -0x2(%rcx), %edx
cmpl $0x4, %edx
jae 0x41ec3
movq 0x20(%r14), %rcx
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x415bd
jmp 0x41ede
xorl %ebx, %ebx
jmp 0x41ede
cmpl $0x2, %ecx
jae 0x41ed9
movq 0x10(%r14), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42825
jmp 0x41ede
cmpl $0x6, %ecx
je 0x41ee7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5f57(%rip), %rdi      # 0x47e45
leaq 0xcad7(%rip), %rsi      # 0x4e9cc
leaq 0xd105(%rip), %rcx      # 0x4f001
movl $0x88a, %edx            # imm = 0x88A
callq 0xe140
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_preop
static struct storage *x86_preop(struct expression *expr)
{
	/*
	 * '*' is an lvalue access, and is fundamentally different
	 * from an arithmetic operation. Maybe it should have an
	 * expression type of its own..
	 */
	if (expr->op == '*')
		return x86_access(expr);
	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
		return emit_inc_dec(expr, 0);
	return emit_regular_preop(expr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl $0x103, %eax            # imm = 0x103
je 0x4212e
cmpl $0x101, %eax            # imm = 0x101
je 0x4212e
cmpl $0x2a, %eax
jne 0x42141
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42797
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x428d1
movq 0x20(%rbx), %rdi
callq 0x40caf
movq %rax, %r15
movl $0x4, %edi
callq 0x41736
movq %rax, %r14
movl 0x4(%rbx), %eax
cmpl $0x7e, %eax
je 0x421fd
cmpl $0x2d, %eax
je 0x421f4
cmpl $0x21, %eax
jne 0x42251
movl $0x4, %edi
callq 0x414f4
movq $0x2, 0x8(%rax)
leaq 0x2766f(%rip), %r12     # 0x69800
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x415bd
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdx
leaq 0x27621(%rip), %r13     # 0x697d0
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x415bd
leaq 0xcb05(%rip), %rdi      # 0x4ecc8
movq %r13, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x4151d
leaq 0xd01b(%rip), %rdi      # 0x4f1f2
leaq 0x27322(%rip), %rsi     # 0x69500
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4151d
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdx
movq %r12, %rdi
jmp 0x4223a
leaq 0xad7d(%rip), %r12      # 0x4cf78
jmp 0x42204
leaq 0x63db(%rip), %r12      # 0x485df
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdx
leaq 0x275bd(%rip), %r13     # 0x697d0
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x415bd
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4151d
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdx
movq %r13, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x415bd
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5bed(%rip), %rdi      # 0x47e45
leaq 0xc76d(%rip), %rsi      # 0x4e9cc
leaq 0xcf91(%rip), %rcx      # 0x4f1f7
movl $0x6a2, %edx            # imm = 0x6A2
callq 0xe140
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_symbol_expr_init
static struct storage *emit_symbol_expr_init(struct symbol *sym)
{
	struct expression *expr = sym->initializer;
	struct symbol_private *priv = sym->aux;

	if (priv == NULL) {
		priv = calloc(1, sizeof(*priv));
		sym->aux = priv;

		if (expr == NULL) {
			struct storage *new = stack_alloc(4);
			fprintf(stderr, "FIXME! no value for symbol %s.  creating pseudo %d (stack offset %d)\n",
				show_ident(sym->ident),
				new->pseudo, new->pseudo * 4);
			priv->addr = new;
		} else {
			priv->addr = x86_expression(expr);
		}
	}

	return priv->addr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x4228a
movq (%rax), %rax
jmp 0x422bd
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x1, %edi
movl $0x8, %esi
callq 0xe1e0
movq %rax, %r14
movq %rax, 0xd0(%rbx)
testq %r15, %r15
je 0x422c7
movq %r15, %rdi
callq 0x40caf
movq %rax, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe9a0
movq (%r15), %rax
jmp 0x422bd
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_string_expr
static struct storage *emit_string_expr(struct expression *expr)
{
	struct function *f = current_func;
	int label = new_label();
	struct storage *new;

	push_cstring(f, expr->string, label);

	new = new_storage(STOR_LABEL);
	new->label = label;
	new->flags = STOR_LABEL_VAL | STOR_WANTS_FREE;
	return new;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x546eb(%rip), %r14     # 0x969d8
movl 0x546ed(%rip), %ebp     # 0x969e0
incl %ebp
movl %ebp, 0x546e5(%rip)     # 0x969e0
movl $0x2, %edi
callq 0x41a4e
movq %rbx, 0x8(%rax)
movl %ebp, 0x10(%rax)
addq $0x18, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c714
movl $0x5, %edi
callq 0x414f4
movl %ebp, 0x20(%rax)
movq $0x3, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_initializer_expr
static void x86_initializer_expr(struct expression *expr, struct symbol *ctype)
{
	struct expression *entry;

	FOR_EACH_PTR(expr->expr_list, entry) {
		// Nested initializers have their positions already
		// recursively calculated - just output them too
		if (entry->type == EXPR_INITIALIZER) {
			x86_initializer_expr(entry, ctype);
			continue;
		}

		// Ignore initializer indexes and identifiers - the
		// evaluator has taken them into account
		if (entry->type == EXPR_IDENTIFIER || entry->type == EXPR_INDEX)
			continue;
		if (entry->type == EXPR_POS) {
			x86_position_expr(entry, ctype);
			continue;
		}
		x86_initialization(ctype, entry);
	} END_FOR_EACH_PTR(entry);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x4250d
movq 0x20(%rsp), %rbx
movzwl (%rbx), %eax
testb %al, %al
jle 0x424fe
xorl %r13d, %r13d
movq 0x18(%rbx,%r13,8), %r12
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x42385
testq %r12, %r12
je 0x424ec
movzbl (%r12), %eax
leal -0x19(%rax), %ecx
cmpl $0x2, %ecx
jb 0x424ec
cmpl $0x1b, %eax
je 0x423b2
cmpl $0x18, %eax
jne 0x423fe
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x42335
jmp 0x424ec
movq 0x28(%r12), %rdi
callq 0x40caf
movq 0x28(%r12), %rcx
movq 0x10(%rcx), %rcx
movl 0x20(%rax), %ebp
movl 0x20(%r12), %r14d
movzbl 0x54(%rcx), %r15d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x21ba5
leaq 0x628e(%rip), %rdi      # 0x48675
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0xe110
jmp 0x424ec
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x424ec
movl 0x50(%rax), %r15d
movq %r12, %rdi
callq 0x40caf
movq %rax, %r12
movl $0x4, %edi
callq 0x41736
movq %rax, %rbp
movq 0x10(%rsp), %rcx
movq 0x68(%rcx), %rax
testb $0x1c, %al
je 0x4246e
leaq 0x25f90(%rip), %rax     # 0x683cc
movl (%rax), %r14d
movq %r12, 0x8(%rsp)
movl %r15d, %r12d
movl 0x20(%rbp), %r15d
movq 0x18(%rcx), %rdi
callq 0x21ba5
leaq 0x6095(%rip), %rdi      # 0x484f0
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %r15d
movq 0x8(%rsp), %r12
movq %rax, %rcx
jmp 0x424cc
btl $0x8, %eax
leaq 0x25f53(%rip), %rax     # 0x683cc
movl (%rax), %r14d
movl 0x20(%rbp), %edx
jb 0x424c0
movq 0x18(%rcx), %rdi
movq %r12, 0x8(%rsp)
movl %r15d, 0x1c(%rsp)
movq %rcx, %r15
movl %edx, %r12d
callq 0x21ba5
leaq 0x607b(%rip), %rdi      # 0x4851c
movl %r14d, %esi
movl %r12d, %edx
movq %rax, %rcx
movq %r15, %r8
movl 0x1c(%rsp), %r15d
movq 0x8(%rsp), %r12
xorl %eax, %eax
callq 0xe110
jmp 0x424d3
leaq 0x603c(%rip), %rdi      # 0x48503
movl %r14d, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe110
movl 0x20(%rbp), %ecx
movl 0x20(%r12), %edx
leaq 0x5fa3(%rip), %rdi      # 0x48485
movl %r15d, %esi
xorl %eax, %eax
callq 0xe110
incq %r13
movl (%rbx), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x4236d
movq 0x10(%rbx), %rbx
cmpq 0x20(%rsp), %rbx
jne 0x4235f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_select_expr
static struct storage *emit_select_expr(struct expression *expr)
{
	struct storage *cond = x86_expression(expr->conditional);
	struct storage *stot = x86_expression(expr->cond_true);
	struct storage *stof = x86_expression(expr->cond_false);
	struct storage *reg_cond, *reg_true, *reg_false;
	struct storage *new = stack_alloc(4);

	emit_comment("begin SELECT");
	reg_cond = get_reg_value(cond, get_regclass(expr->conditional));
	reg_true = get_reg_value(stot, get_regclass(expr));
	reg_false = get_reg_value(stof, get_regclass(expr));

	/*
	 * Do the actual select: check the conditional for zero,
	 * move false over true if zero
	 */ 
	insn("test", reg_cond, reg_cond, NULL);
	insn("cmovz", reg_false, reg_true, NULL);

	/* Store it back */
	emit_move(reg_true, new, expr->ctype, NULL);
	put_reg(reg_cond);
	put_reg(reg_true);
	put_reg(reg_false);
	emit_comment("end SELECT");
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x40caf
movq %rax, %r12
movq 0x28(%r14), %rdi
callq 0x40caf
movq %rax, %rbp
movq 0x30(%r14), %rdi
callq 0x40caf
movq %rax, %r15
movl $0x4, %edi
callq 0x41736
movq %rax, %rbx
leaq 0xcd2f(%rip), %rdi      # 0x4f291
xorl %eax, %eax
callq 0x4189d
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
leaq 0x27875(%rip), %r13     # 0x69df0
movq %r13, %rsi
cmpl $0x8, %eax
je 0x425a6
cmpl $0x40, %eax
je 0x42596
cmpl $0x10, %eax
jne 0x4259f
leaq 0x27884(%rip), %rsi     # 0x69e18
jmp 0x425a6
leaq 0x278a3(%rip), %rsi     # 0x69e40
jmp 0x425a6
leaq 0x27822(%rip), %rsi     # 0x69dc8
movq %r12, %rdi
callq 0x41958
movq %rax, %r12
movq 0x10(%r14), %rax
movl 0x50(%rax), %eax
movq %r13, %rsi
cmpl $0x8, %eax
je 0x425e3
cmpl $0x40, %eax
je 0x425d3
cmpl $0x10, %eax
jne 0x425dc
leaq 0x27847(%rip), %rsi     # 0x69e18
jmp 0x425e3
leaq 0x27866(%rip), %rsi     # 0x69e40
jmp 0x425e3
leaq 0x277e5(%rip), %rsi     # 0x69dc8
movq %rbp, %rdi
callq 0x41958
movq %rax, %rbp
movq 0x10(%r14), %rax
movl 0x50(%rax), %eax
cmpl $0x8, %eax
je 0x4261d
cmpl $0x40, %eax
je 0x4260d
cmpl $0x10, %eax
jne 0x42616
leaq 0x2780d(%rip), %r13     # 0x69e18
jmp 0x4261d
leaq 0x2782c(%rip), %r13     # 0x69e40
jmp 0x4261d
leaq 0x277ab(%rip), %r13     # 0x69dc8
movq %r15, %rdi
movq %r13, %rsi
callq 0x41958
movq %rax, %r15
leaq 0xc696(%rip), %rdi      # 0x4ecc8
movq %r12, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x4151d
leaq 0xcc58(%rip), %rdi      # 0x4f29e
movq %r15, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x4151d
movq 0x10(%r14), %rdx
movq %rbp, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x415bd
movq 0x10(%r12), %rax
movl 0x10(%rax), %edi
callq 0x419d9
movq 0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x419d9
movq 0x10(%r15), %rax
movl 0x10(%rax), %edi
callq 0x419d9
leaq 0xcc14(%rip), %rdi      # 0x4f2a4
xorl %eax, %eax
callq 0x4189d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_conditional_expr
static struct storage *emit_conditional_expr(struct expression *expr)
{
	struct storage *cond, *stot = NULL, *stof = NULL;
	struct storage *new = stack_alloc(expr->ctype->bit_size / 8);
	int target_false, cond_end;

	/* evaluate conditional */
	cond = x86_expression(expr->conditional);
	target_false = emit_conditional_test(cond);

	/* handle if-true part of the expression */
	stot = x86_expression(expr->cond_true);

	emit_copy(new, stot, expr->ctype);

	cond_end = emit_conditional_end(target_false);

	/* handle if-false part of the expression */
	stof = x86_expression(expr->cond_false);

	emit_copy(new, stof, expr->ctype);

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

	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movl 0x50(%rax), %eax
leal 0x7(%rax), %edi
testl %eax, %eax
cmovnsl %eax, %edi
sarl $0x3, %edi
callq 0x41736
movq %rax, %rbx
movq 0x20(%r14), %rdi
callq 0x40caf
movq %rax, %rdi
callq 0x417a8
movl %eax, %ebp
movq 0x28(%r14), %rdi
callq 0x40caf
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42825
movl %ebp, %edi
callq 0x41826
movl %eax, %ebp
movq 0x30(%r14), %rdi
callq 0x40caf
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42825
movq 0x542b5(%rip), %r14     # 0x969d8
leaq 0xc649(%rip), %rsi      # 0x4ed73
leaq 0xcb7e(%rip), %rcx      # 0x4f2af
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0xe2f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0d
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_address_gen
static struct storage *x86_address_gen(struct expression *expr)
{
	struct function *f = current_func;
	struct storage *addr;
	struct storage *new;
	char s[32];

	addr = x86_expression(expr->unop);
	if (expr->unop->type == EXPR_SYMBOL)
		return addr;

	emit_move(addr, REG_EAX, NULL, "begin deref ..");

	/* FIXME: operand size */
	strcpy(s, "\tmovl\t(%eax), %ecx\n");
	push_text_atom(f, s);

	new = stack_alloc(4);
	emit_move(REG_ECX, new, NULL, ".... end deref");

	return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq 0x5422e(%rip), %rbx     # 0x969d8
movq 0x20(%rdi), %rdi
callq 0x40caf
movq %rax, %r14
movq 0x20(%r15), %rax
cmpb $0x3, (%rax)
je 0x42818
leaq 0x2700a(%rip), %rsi     # 0x697d0
leaq 0xc868(%rip), %rcx      # 0x4f035
movq %r14, %rdi
xorl %edx, %edx
callq 0x415bd
movaps 0xcaf2(%rip), %xmm0     # 0x4f2d0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0xa7863, 0x10(%rsi)    # imm = 0xA7863
movq %rbx, %rdi
callq 0x41a0d
movl $0x4, %edi
callq 0x41736
movq %rax, %r14
leaq 0x27029(%rip), %rdi     # 0x69830
leaq 0xc836(%rip), %rcx      # 0x4f044
movq %rax, %rsi
xorl %edx, %edx
callq 0x415bd
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_copy
static void emit_copy(struct storage *dest, struct storage *src,
		      struct symbol *ctype)
{
	struct storage *reg = NULL;
	unsigned int bit_size;

	/* FIXME: Bitfield copy! */

	bit_size = src->size * 8;
	if (!bit_size)
		bit_size = 32;
	if ((src->type == STOR_ARG) && (bit_size < 32))
		bit_size = 32;

	reg = temp_from_bits(bit_size);
	emit_move(src, reg, ctype, "begin copy ..");

	bit_size = dest->size * 8;
	if (!bit_size)
		bit_size = 32;
	if ((dest->type == STOR_ARG) && (bit_size < 32))
		bit_size = 32;

	emit_move(reg, dest, ctype, ".... end copy");
	put_reg(reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x28(%rsi), %eax
leal (,%rax,8), %ecx
testl %eax, %eax
movl $0x20, %eax
cmovel %eax, %ecx
cmpl $0x21, %ecx
cmovael %ecx, %eax
cmpl $0x1, (%rsi)
movq %rdi, %r15
cmovnel %ecx, %eax
cmpl $0x8, %eax
je 0x42877
cmpl $0x40, %eax
je 0x4286e
cmpl $0x10, %eax
jne 0x42880
leaq 0x275ac(%rip), %rdi     # 0x69e18
jmp 0x42887
leaq 0x275cb(%rip), %rdi     # 0x69e40
jmp 0x42887
leaq 0x27572(%rip), %rdi     # 0x69df0
jmp 0x42887
leaq 0x27541(%rip), %rdi     # 0x69dc8
callq 0x41af8
movq %rax, %r12
leaq 0xc7bd(%rip), %rcx      # 0x4f053
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x415bd
leaq 0xc7b6(%rip), %rcx      # 0x4f061
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x415bd
movq 0x10(%r12), %rax
movl 0x10(%rax), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x419d9
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_inc_dec
static struct storage *emit_inc_dec(struct expression *expr, int postop)
{
	struct storage *addr = x86_address_gen(expr->unop);
	struct storage *retval;
	char opname[16];

	strcpy(opname, opbits(expr->op == SPECIAL_INCREMENT ? "inc" : "dec",
			      expr->ctype->bit_size));

	if (postop) {
		struct storage *new = stack_alloc(4);

		emit_copy(new, addr, expr->unop->ctype);

		retval = new;
	} else
		retval = addr;

	insn(opname, addr, NULL, NULL);

	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x42797
movq %rax, %rbx
cmpl $0x101, 0x4(%r14)       # imm = 0x101
leaq 0x14c4(%rip), %rax      # 0x43dbf
leaq 0xc8ec(%rip), %rdi      # 0x4f1ee
cmoveq %rax, %rdi
movq 0x10(%r14), %rax
movl 0x50(%rax), %esi
callq 0x416f7
leaq 0x540d7(%rip), %rsi     # 0x969f0
movq %rsp, %rdi
callq 0xe0a0
movq %rbx, %r15
testl %ebp, %ebp
je 0x42948
movl $0x4, %edi
callq 0x41736
movq %rax, %r15
movq 0x20(%r14), %rax
movq 0x10(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42825
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4151d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
			unsigned char *c,unsigned long long *clen,
			const unsigned char *m,unsigned long long mlen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *nsec,
			const unsigned char *npub,
			const unsigned char *k
			) {
   (void)nsec;

   int res = omdsha256_process(c, k, m, mlen, ad, adlen, npub, OMD_ENCRYPT);

   if (res != -1)
      *clen = mlen + CRYPTO_ABYTES;

   return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq 0x30(%rsp), %rsi
pushq $0x0
pushq 0x30(%rsp)
callq 0x10d0
addq $0x10, %rsp
cmpl $-0x1, %eax
je 0x1206
addq $0x14, %rbx
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
			unsigned char *m,unsigned long long *mlen,
			unsigned char *nsec,
			const unsigned char *c,unsigned long long clen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *npub,
			const unsigned char *k
			) {
   (void)nsec;

   int res = omdsha256_process(m, k, c, clen, ad, adlen, npub, OMD_DECRYPT);

   if (res != -1)
      *mlen = clen - CRYPTO_ABYTES;

   return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %rbx
movq %rsi, %r14
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %r9
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
pushq $0x1
pushq 0x30(%rsp)
callq 0x10d0
addq $0x10, %rsp
cmpl $-0x1, %eax
je 0x1249
addq $-0x14, %rbx
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/omdsha256.c
// Function: double_block
void
double_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n-1; i++)
       {
	  /* shift with carry from next block */
	  res[i] = (in[i] << 1) | (in[i+1] >> 7);
       }

    res[OMD_n -1] = (in[OMD_n -1] << 1);

	if(carry) {
    	/* xor P(x) if msb */
    	res[OMD_n -2] = res[OMD_n -2] ^ 0x04;
    	/* shift and xor P(x) if msb */
    	res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
    }
}

// Assembly:
movb (%rsi), %al
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
movb 0x1(%rsi,%rcx), %r8b
shrb $0x7, %r8b
addb %dl, %dl
orb %r8b, %dl
movb %dl, (%rdi,%rcx)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq $0x1f, %rdx
jne 0x126d
movb 0x1f(%rsi), %cl
addb %cl, %cl
movb %cl, 0x1f(%rdi)
testb %al, %al
js 0x129b
retq
xorb $0x4, 0x1e(%rdi)
xorb $0x25, %cl
movb %cl, 0x1f(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/omdsha256.c
// Function: triple_block
void
triple_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n -1; i++)
       {
	  /* shift and xor */
	  res[i] = in[i] ^ ((in[i] << 1) | (in[i+1] >> 7));
       }

    res[OMD_n -1] = in[OMD_n -1] ^ (in[OMD_n -1] << 1);
	
	/* xor P(x) if msb */
	if(carry) {
    	res[OMD_n -2] = res[OMD_n -2] ^ 0x04;
	    res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
    }
}

// Assembly:
movb (%rsi), %al
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
movb 0x1(%rsi,%rcx), %r8b
shrb $0x7, %r8b
leal (%rdx,%rdx), %r9d
orb %r8b, %r9b
xorb %dl, %r9b
movb %r9b, (%rdi,%rcx)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq $0x1f, %rdx
jne 0x12aa
movb 0x1f(%rsi), %dl
leal (%rdx,%rdx), %ecx
xorb %dl, %cl
movb %cl, 0x1f(%rdi)
testb %al, %al
js 0x12e1
retq
xorb $0x4, 0x1e(%rdi)
xorb $0x25, %cl
movb %cl, 0x1f(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/omdsha256.c
// Function: calc_L_i
void
calc_L_i (hashblock l, const hashblock lzero, unsigned int i)
{
   /* i==0 => l=lzero */
   if (i == 0)
      {
	 memcpy(l, lzero, OMD_n );
	 return;
      }

   double_block(l,lzero);

   /* L[i]=2.L[i-1] */
   while (--i)
      {
	 double_block(l,l);
      }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x1356
movl %edx, %ebp
movq %rbx, %rdi
callq 0x1060
decl %ebp
je 0x135e
movq %rbx, %rdi
movq %rbx, %rsi
jmp 0x1345
vmovups (%rsi), %ymm0
vmovups %ymm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/omdsha256.c
// Function: increment_masking_message
void
increment_masking_message (hashblock delta_n, const hashblock delta_o,
			   const hashblock lzero, int i)
{
   hashblock l;

   if (i < 1)
      {
	 return;
      }

   /* \delta_{N, i, 0} = \delta_{N, i-1, 0} ^ L[ntz(i)]  */
   calc_L_i(l, lzero, ntz(i));
   xor_block(delta_n, delta_o, l);

}

// Assembly:
testl %ecx, %ecx
jle 0x13d1
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
blsmskl %ecx, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x13a8
xorl %eax, %eax
sarl %ecx
incl %eax
cmpl $0x1, %ecx
ja 0x139f
movq %rsp, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x10a0
xorl %eax, %eax
movb (%rsp,%rax), %cl
xorb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x13b7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/omdsha256k256n104tau160v2/ref/omdsha256.c
// Function: final_masking_message
void
final_masking_message (hashblock delta_n, const hashblock delta_o,
		       const hashblock lstar, int j)
{
   hashblock l;

   switch (j)
      {
      case 1:
	 /* \delta_{N, i, 1} = \delta_{N, i, 0} ^ 2*L_*  */
	 double_block (l, lstar);
	 xor_block (delta_n, delta_o, l);
	 break;

      case 2:
	 /* \delta_{N, i, 2} = \delta_{N, i, 0} ^ 3*L_*  */
	 triple_block (l, lstar);
	 xor_block (delta_n, delta_o, l);
	 break;
      }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %ecx
je 0x140b
cmpl $0x1, %ecx
jne 0x142b
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1060
xorl %eax, %eax
movb (%rsp,%rax), %cl
xorb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x13f6
jmp 0x142b
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x10b0
xorl %eax, %eax
movb (%rsp,%rax), %cl
xorb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x1418
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: getchoice
static int getchoice(int *argip, int argc, char *argv[], const char *options[])
{
  const char *arg = getvalue(argip, argc, argv);

  int value = -1;
  while(options[++value])
    if(streq(arg, options[value]))
      return value;

  fprintf(stderr, "Unrecognised option value %s\n", arg);
  exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
callq 0x1aa7
movq %rax, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1954
movq %r14, %rdi
callq 0x1070
incl %ebp
addq $0x8, %rbx
testl %eax, %eax
jne 0x1933
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x119a
// File: /workspace/github_c_makefile_star2_O3/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: do_dec_mode
static void do_dec_mode(int mode, BoolQuery val, const char *name)
{
  switch(val) {
    case OFF:
    case ON:
      printf("\x1b[?%d%c", mode, val == ON ? 'h' : 'l');
      break;

    case QUERY:
      if(query_dec_mode(mode))
        printf("%s on\n", name);
      else
        printf("%s off\n", name);
      break;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebp
cmpl $0x2, %esi
jae 0x199e
xorl %eax, %eax
cmpl $0x1, %esi
setne %al
leal 0x68(,%rax,4), %edx
leaq 0x8d5(%rip), %rdi       # 0x225c
movl %ebp, %esi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
jne 0x1a98
movq %rdx, 0x8(%rsp)
leaq 0x8c3(%rip), %rdi       # 0x2273
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
leaq 0x10(%rsp), %r14
leaq 0x8b6(%rip), %r15       # 0x227b
leaq 0x4(%rsp), %r12
leaq 0x3(%rsp), %r13
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x19de
movq %rbx, %rdi
callq 0x1030
movl $0x9b, %edi
callq 0x1abe
xorl %ebx, %ebx
callq 0x1080
movb %al, 0x10(%rsp,%rbx)
movsbl %al, %eax
addl $-0x40, %eax
cmpl $0x3f, %eax
jb 0x1a0c
incq %rbx
cmpq $0x1f, %rbx
jne 0x19ea
movl $0x1f, %ebx
incl %ebx
movb $0x0, 0x10(%rsp,%rbx)
movq %r14, %rdi
callq 0x1100
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x10a0
cmpl $0x3, %eax
jl 0x19d1
cmpb $0x79, 0x3(%rsp)
jne 0x19d1
cmpl %ebp, 0x10(%rsp)
jne 0x19d1
movq %rbx, %rdi
callq 0x1030
movl 0x4(%rsp), %esi
movl %esi, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x1a6a
leaq 0x801(%rip), %rdi       # 0x2264
movq 0x8(%rsp), %rsi
jmp 0x1a91
cmpl $0x2, %esi
movq 0x8(%rsp), %rbx
je 0x1a87
cmpl $0x4, %esi
je 0x1a87
leaq 0x805(%rip), %rdi       # 0x2285
xorl %eax, %eax
callq 0x1060
leaq 0x7dd(%rip), %rdi       # 0x226b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: await_c1
static void await_c1(unsigned char c1)
{
  unsigned char c;

  /* await CSI - 8bit or 2byte 7bit form */
  bool in_esc = false;
  while((c = getchar())) {
    if(c == c1)
      break;
    if(in_esc && c == (char)(c1 - 0x40))
      break;
    if(!in_esc && c == 0x1b)
      in_esc = true;
    else
      in_esc = false;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x1080
movl %eax, %ecx
andl $0xff, %ecx
je 0x1b04
leal -0x40(%rbx), %ebp
xorl %r14d, %r14d
cmpb %al, %bpl
sete %dl
cmpb %bl, %al
je 0x1b04
andb %r14b, %dl
jne 0x1b04
xorb $0x1, %r14b
cmpl $0x1b, %ecx
sete %al
andb %al, %r14b
callq 0x1080
movl %eax, %ecx
andl $0xff, %ecx
jne 0x1ad9
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)