LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0x64bbb
movq -0x10(%rbp), %rax
leaq 0xdc9d(%rip), %rcx      # 0x72728
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x64c20
movl %eax, %edi
callq 0x64bd0
movq %rax, %rsi
leaq 0x5bb42(%rip), %rdi     # 0xc05f0
callq 0x110a0
jmp 0x64bbb
movq -0x8(%rbp), %rdi
callq 0x64c50
movl %eax, %edi
callq 0x64bd0
movq %rax, %rsi
leaq 0x5bb1e(%rip), %rdi     # 0xc05f0
callq 0x110a0
jmp 0x64bbb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movq %rax, %rsi
leaq 0x5baf9(%rip), %rdi     # 0xc05f0
callq 0x110a0
jmp 0x64bbb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
leaq 0x5badd(%rip), %rdi     # 0xc05f0
callq 0x110a0
jmp 0x64bbb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x5bac4(%rip), %rdi     # 0xc05f0
leaq 0xb9af(%rip), %rsi      # 0x704e2
movb $0x0, %al
callq 0x112f0
jmp 0x64bbb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
leaq 0x2cda(%rip), %rdx      # 0x67829
leaq 0xe233(%rip), %rax      # 0x72d89
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0x5ba84(%rip), %rdi     # 0xc05f0
leaq 0xe20f(%rip), %rsi      # 0x72d82
movb $0x0, %al
callq 0x112f0
jmp 0x64bbb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
leaq 0x2c9a(%rip), %rdx      # 0x67829
leaq 0xe1f3(%rip), %rax      # 0x72d89
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x5ba43(%rip), %rdi     # 0xc05f0
leaq 0xe1d7(%rip), %rsi      # 0x72d8b
movb $0x0, %al
callq 0x112f0
leaq 0x5ba2e(%rip), %rax     # 0xc05f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: pretty_offset
static const char *pretty_offset(int ofs)
{
	static char esp_buf[64];

	if (ofs)
		sprintf(esp_buf, "%d(%%esp)", ofs);
	else
		strcpy(esp_buf, "(%esp)");

	return esp_buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x64bfb
movl -0x4(%rbp), %edx
leaq 0x5ba25(%rip), %rdi     # 0xc0610
leaq 0xe1a1(%rip), %rsi      # 0x72d93
movb $0x0, %al
callq 0x112f0
jmp 0x64c0e
leaq 0x5ba0e(%rip), %rdi     # 0xc0610
leaq 0xe194(%rip), %rsi      # 0x72d9d
callq 0x110a0
leaq 0x5b9fb(%rip), %rax     # 0xc0610
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x65010
movq $0x0, -0x8(%rbp)
jmp 0x650b2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x65d80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x2, %eax
jb 0x65055
jmp 0x6503e
movl -0x2c(%rbp), %eax
addl $-0x2, %eax
subl $0x4, %eax
jb 0x6506c
jmp 0x6504b
movl -0x2c(%rbp), %eax
subl $0x6, %eax
je 0x6508b
jmp 0x650aa
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x65e50
jmp 0x650aa
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x63640
jmp 0x650aa
leaq 0x67e7(%rip), %rdi      # 0x6b879
leaq 0xd6fb(%rip), %rsi      # 0x72794
movl $0x88a, %edx            # imm = 0x88A
leaq 0xdd62(%rip), %rcx      # 0x72e07
callq 0x11140
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2a, 0x4(%rax)
jne 0x656c5
movq -0x10(%rbp), %rdi
callq 0x66140
movq %rax, -0x8(%rbp)
jmp 0x656fd
movq -0x10(%rbp), %rax
cmpl $0x101, 0x4(%rax)       # imm = 0x101
je 0x656df
movq -0x10(%rbp), %rax
cmpl $0x103, 0x4(%rax)       # imm = 0x103
jne 0x656f0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x66160
movq %rax, -0x8(%rbp)
jmp 0x656fd
movq -0x10(%rbp), %rdi
callq 0x66220
movq %rax, -0x8(%rbp)
movq -0x8(%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: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x65801
movl $0x1, %edi
movl $0x8, %esi
callq 0x111d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x657ec
movl $0x4, %edi
callq 0x63a00
movq %rax, -0x20(%rbp)
movq 0x2584d(%rip), %rax     # 0x8aff0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %r8d
shll $0x2, %r8d
leaq 0xd871(%rip), %rsi      # 0x73049
movb $0x0, %al
callq 0x111f0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x657ff
movq -0x10(%rbp), %rdi
callq 0x62220
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x65801
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_cast_expr
static struct storage *emit_cast_expr(struct expression *expr)
{
	struct symbol *old_type, *new_type;
	struct storage *op = x86_expression(expr->cast_expression);
	int oldbits, newbits;
	struct storage *new;

	old_type = expr->cast_expression->ctype;
	new_type = expr->cast_type;

	oldbits = old_type->bit_size;
	newbits = new_type->bit_size;
	if (oldbits >= newbits)
		return op;

	emit_move(op, REG_EAX, old_type, "begin cast ..");

	new = stack_alloc(newbits / 8);
	emit_move(REG_EAX, new, new_type, ".... end cast");

	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x62220
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jl 0x6586f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x658d1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2d012(%rip), %rsi     # 0x92890
addq $0x330, %rsi            # imm = 0x330
leaq 0xd803(%rip), %rcx      # 0x7308f
callq 0x63640
movl -0x30(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x63a00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x2cfda(%rip), %rdi     # 0x92890
addq $0x330, %rdi            # imm = 0x330
leaq 0xd7d9(%rip), %rcx      # 0x7309d
callq 0x63640
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5a485(%rip), %rax     # 0xbfdb8
movq %rax, -0x10(%rbp)
callq 0x62b30
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x66410
movl $0x5, %edi
callq 0x63490
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x3, 0x8(%rax)
movq -0x20(%rbp), %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: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%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 0x659c8
jmp 0x65aac
jmp 0x659ca
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 0x65a94
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 0x65a19
cmpq $0x0, -0x18(%rbp)
jne 0x65a19
jmp 0x65a86
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x18, %eax
jne 0x65a38
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x65990
jmp 0x65a86
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x19, %eax
je 0x65a58
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1a, %eax
jne 0x65a5a
jmp 0x65a86
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
jne 0x65a79
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x66470
jmp 0x65a86
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x66500
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x659d1
jmp 0x65a96
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x659ca
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x62220
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x62220
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
movl $0x4, %edi
callq 0x63a00
movq %rax, -0x40(%rbp)
leaq 0xd597(%rip), %rdi      # 0x730ab
movb $0x0, %al
callq 0x63c40
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x65fb0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x63d20
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65fb0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x63d20
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65fb0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x63d20
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0xcf20(%rip), %rdi      # 0x72ab1
xorl %eax, %eax
movl %eax, %ecx
callq 0x63500
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0xd50f(%rip), %rdi      # 0x730b8
xorl %eax, %eax
movl %eax, %ecx
callq 0x63500
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x63640
movq -0x28(%rbp), %rdi
callq 0x63df0
movq -0x30(%rbp), %rdi
callq 0x63df0
movq -0x38(%rbp), %rdi
callq 0x63df0
leaq 0xd4d1(%rip), %rdi      # 0x730be
movb $0x0, %al
callq 0x63c40
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x63a00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x62220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63ac0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x62220
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x65e50
movl -0x2c(%rbp), %edi
callq 0x63b60
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x65e50
movl -0x30(%rbp), %edi
leaq 0xd411(%rip), %rsi      # 0x730c9
callq 0x63bd0
movq -0x28(%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: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq 0x5a025(%rip), %rax     # 0xbfdb8
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x65dc6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x65e3d
movq -0x20(%rbp), %rdi
leaq 0x2cabf(%rip), %rsi     # 0x92890
addq $0x330, %rsi            # imm = 0x330
xorl %eax, %eax
movl %eax, %edx
leaq 0xd058(%rip), %rcx      # 0x72e3b
callq 0x63640
leaq -0x50(%rbp), %rdi
leaq 0xd057(%rip), %rsi      # 0x72e4a
callq 0x110a0
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x63e60
movl $0x4, %edi
callq 0x63a00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x2ca72(%rip), %rdi     # 0x92890
addq $0x390, %rdi            # imm = 0x390
xorl %eax, %eax
movl %eax, %edx
leaq 0xd02e(%rip), %rcx      # 0x72e5e
callq 0x63640
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
shll $0x3, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x65e86
movl $0x20, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x65e9c
cmpl $0x20, -0x24(%rbp)
jae 0x65e9c
movl $0x20, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x65f20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xcfb2(%rip), %rcx      # 0x72e6d
callq 0x63640
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
shll $0x3, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x65eda
movl $0x20, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x65ef0
cmpl $0x20, -0x24(%rbp)
jae 0x65ef0
movl $0x20, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xcf78(%rip), %rcx      # 0x72e7b
callq 0x63640
movq -0x20(%rbp), %rdi
callq 0x63df0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: get_regclass_bits
static struct regclass *get_regclass_bits(int bits)
{
	switch (bits) {
	case 8: return &regclass_8;
	case 16: return &regclass_16;
	case 64: return &regclass_64;
	default: return &regclass_32;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x8, %eax
je 0x65f78
jmp 0x65f64
movl -0x10(%rbp), %eax
subl $0x10, %eax
je 0x65f85
jmp 0x65f6e
movl -0x10(%rbp), %eax
subl $0x40, %eax
je 0x65f92
jmp 0x65f9f
leaq 0x2d261(%rip), %rax     # 0x931e0
movq %rax, -0x8(%rbp)
jmp 0x65faa
leaq 0x2d27c(%rip), %rax     # 0x93208
movq %rax, -0x8(%rbp)
jmp 0x65faa
leaq 0x2d297(%rip), %rax     # 0x93230
movq %rax, -0x8(%rbp)
jmp 0x65faa
leaq 0x2d212(%rip), %rax     # 0x931b8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_divide
static struct storage *emit_divide(struct expression *expr, struct storage *left, struct storage *right)
{
	struct storage *eax_edx;
	struct storage *reg, *new;
	struct storage *val = new_storage(STOR_VALUE);

	emit_comment("begin DIVIDE");
	eax_edx = get_hardreg(hardreg_storage_table + EAX_EDX, 1);

	/* init EDX to 0 */
	val->flags = STOR_WANTS_FREE;
	emit_move(val, REG_EDX, NULL, NULL);

	new = stack_alloc(expr->ctype->bit_size / 8);

	/* EAX is dividend */
	emit_move(left, REG_EAX, NULL, NULL);

	reg = get_reg_value(right, &regclass_32);

	/* perform binop */
	insn("div", reg, REG_EAX, NULL);
	put_reg(reg);

	reg = REG_EAX;
	if (expr->op == '%')
		reg = REG_EDX;
	emit_move(reg, new, NULL, NULL);

	put_reg(eax_edx);
	emit_comment("end DIVIDE");
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x4, %edi
callq 0x63490
movq %rax, -0x38(%rbp)
leaq 0xcfe7(%rip), %rdi      # 0x72ff0
movb $0x0, %al
callq 0x63c40
leaq 0x2c879(%rip), %rdi     # 0x92890
addq $0x4b0, %rdi            # imm = 0x4B0
movl $0x1, %esi
callq 0x63f50
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq $0x2, 0x8(%rax)
movq -0x38(%rbp), %rdi
leaq 0x2c84d(%rip), %rsi     # 0x92890
addq $0x360, %rsi            # imm = 0x360
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63640
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x63a00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2c811(%rip), %rsi     # 0x92890
addq $0x330, %rsi            # imm = 0x330
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63640
movq -0x18(%rbp), %rdi
leaq 0x2d11b(%rip), %rsi     # 0x931b8
callq 0x63d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x693a(%rip), %rdi      # 0x6c9eb
leaq 0x2c7d8(%rip), %rdx     # 0x92890
addq $0x330, %rdx            # imm = 0x330
xorl %eax, %eax
movl %eax, %ecx
callq 0x63500
movq -0x28(%rbp), %rdi
callq 0x63df0
leaq 0x2c7b8(%rip), %rax     # 0x92890
addq $0x330, %rax            # imm = 0x330
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x25, 0x4(%rax)
jne 0x660fd
leaq 0x2c79d(%rip), %rax     # 0x92890
addq $0x360, %rax            # imm = 0x360
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63640
movq -0x20(%rbp), %rdi
callq 0x63df0
leaq 0xcedc(%rip), %rdi      # 0x72ffd
movb $0x0, %al
callq 0x63c40
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x65d80
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0xce72(%rip), %rdi      # 0x73008
leaq 0x1c53(%rip), %rax      # 0x67df0
cmpl $0x101, %ecx            # imm = 0x101
cmoveq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %esi
callq 0x638d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
cmpl $0x0, -0xc(%rbp)
je 0x661fa
movl $0x4, %edi
callq 0x63a00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x65e50
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x66202
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63500
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: push_cstring
static inline void push_cstring(struct function *f, struct string *str,
				int label)
{
	struct atom *atom;

	atom = new_atom(ATOM_CSTR);
	atom->string = str;
	atom->label = label;

	add_ptr_list(&f->str_list, atom);	/* note: _not_ atom_list */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x2, %edi
callq 0x63ec0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x281e0
movq %rax, -0x30(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_position_expr
static int x86_position_expr(struct expression *expr, struct symbol *base)
{
	struct storage *new = x86_expression(expr->init_expr);
	struct symbol *ctype = expr->init_expr->ctype;

	printf("\tinsert v%d at [%d:%d] of %s\n", new->pseudo,
		expr->init_offset, ctype->bit_offset,
		show_ident(base->ident));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x62220
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movq %rax, %r8
leaq 0x5bfe(%rip), %rdi      # 0x6c0e2
movb $0x0, %al
callq 0x11110
xorl %eax, %eax
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_initialization
static int x86_initialization(struct symbol *sym, struct expression *expr)
{
	struct storage *val, *addr;
	int bits;

	if (!expr->ctype)
		return 0;

	bits = expr->ctype->bit_size;
	val = x86_expression(expr);
	addr = x86_symbol_expr(sym);
	// FIXME! The "target" expression is for bitfield store information.
	// Leave it NULL, which works fine.
	emit_store(NULL, addr, val, bits);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x66524
movl $0x0, -0x4(%rbp)
jmp 0x66567
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66570
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x66680
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_symbol_expr
static struct storage *x86_symbol_expr(struct symbol *sym)
{
	struct storage *new = stack_alloc(4);

	if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
		printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer, new->pseudo, show_ident(sym->ident));
		return new;
	}
	if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
		printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer, new->pseudo, 0LL);
		return new;
	}
	printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer, new->pseudo, show_ident(sym->ident), sym);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x4, %edi
callq 0x63a00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x1c, %rax
cmpq $0x0, %rax
je 0x665e3
leaq 0x2ab69(%rip), %rax     # 0x9110c
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq %rax, %rcx
leaq 0x598e(%rip), %rdi      # 0x6bf5d
movb $0x0, %al
callq 0x11110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66669
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x100, %rax            # imm = 0x100
cmpq $0x0, %rax
je 0x66623
leaq 0x2ab0e(%rip), %rax     # 0x9110c
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %edx
leaq 0x5962(%rip), %rdi      # 0x6bf70
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x11110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66669
leaq 0x2aae2(%rip), %rax     # 0x9110c
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
movq %rax, %rcx
movq -0x10(%rbp), %r8
leaq 0x592f(%rip), %rdi      # 0x6bf89
movb $0x0, %al
callq 0x11110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x58(%rsp), %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x1100
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
je 0x12d4
movq 0x28(%rsp), %rcx
addq $0x14, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x1100
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
je 0x1361
movq 0x20(%rsp), %rcx
subq $0x14, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movb %al, -0x15(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x1f, -0x14(%rsp)
jae 0x143b
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x13f3
movq -0x10(%rsp), %rax
movzbl 0x1f(%rax), %eax
shll %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1f(%rax)
cmpb $0x0, -0x15(%rsp)
je 0x1483
movq -0x8(%rsp), %rax
movzbl 0x1e(%rax), %eax
xorl $0x4, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1e(%rax)
movq -0x8(%rsp), %rax
movzbl 0x1f(%rax), %eax
xorl $0x25, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1f(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movb %al, -0x15(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x1f, -0x14(%rsp)
jae 0x150a
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
shll %ecx
movq -0x10(%rsp), %rdx
movl -0x14(%rsp), %esi
addl $0x1, %esi
movl %esi, %esi
movzbl (%rdx,%rsi), %edx
sarl $0x7, %edx
orl %edx, %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x14b3
movq -0x10(%rsp), %rax
movzbl 0x1f(%rax), %eax
movq -0x10(%rsp), %rcx
movzbl 0x1f(%rcx), %ecx
shll %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1f(%rax)
cmpb $0x0, -0x15(%rsp)
je 0x155d
movq -0x8(%rsp), %rax
movzbl 0x1e(%rax), %eax
xorl $0x4, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1e(%rax)
movq -0x8(%rsp), %rax
movzbl 0x1f(%rax), %eax
xorl $0x25, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1f(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1693
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x16c3
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1070
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0x16c3
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1070
jmp 0x16a2
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
cmpl $0x1, 0x3c(%rsp)
jge 0x1740
jmp 0x1780
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
callq 0x1130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
callq 0x10d0
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1140
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x17c1
jmp 0x17b6
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x17e6
jmp 0x1809
leaq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1070
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1140
jmp 0x1809
leaq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x10e0
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1140
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: seticanon
static bool seticanon(bool icanon, bool echo)
{
  struct termios termios;

  tcgetattr(0, &termios);

  bool ret = (termios.c_lflag & ICANON);

  if(icanon) termios.c_lflag |=  ICANON;
  else       termios.c_lflag &= ~ICANON;

  if(echo) termios.c_lflag |=  ECHO;
  else     termios.c_lflag &= ~ECHO;

  tcsetattr(0, TCSANOW, &termios);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x10a0
movl -0x34(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x1(%rbp)
je 0x1256
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x125f
movl -0x34(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x34(%rbp)
testb $0x1, -0x2(%rbp)
je 0x1270
movl -0x34(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x34(%rbp)
jmp 0x1279
movl -0x34(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x34(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x10b0
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: usage
static void usage(int exitcode)
{
  fprintf(stderr, "Control a libvterm-based terminal\n"
      "\n"
      "Options:\n");

  for(char **p = helptext; *p; p++)
    fprintf(stderr, "  %s\n", *p);

  exit(exitcode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x2776(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x8c0(%rip), %rsi       # 0x214c
movb $0x0, %al
callq 0x1080
leaq 0x27f6(%rip), %rax      # 0x4090
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x18d5
movq 0x2749(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x8b9(%rip), %rsi       # 0x2179
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x189e
movl -0x4(%rbp), %edi
callq 0x10d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1bc0
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x194e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1060
cmpl $0x0, %eax
jne 0x194c
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x1912
movq 0x26a3(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x919(%rip), %rsi       # 0x227c
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
jb 0x19a9
jmp 0x199f
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x19cf
jmp 0x1a05
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %ecx
movl $0x6c, %edx
movl $0x68, %eax
cmpl $0x1, %ecx
cmovel %eax, %edx
leaq 0x8d4(%rip), %rdi       # 0x229a
movb $0x0, %al
callq 0x1050
jmp 0x1a05
movl -0x4(%rbp), %edi
callq 0x1c20
testb $0x1, %al
jne 0x19dd
jmp 0x19f1
movq -0x10(%rbp), %rsi
leaq 0x8ba(%rip), %rdi       # 0x22a2
movb $0x0, %al
callq 0x1050
jmp 0x1a03
movq -0x10(%rbp), %rsi
leaq 0x8ad(%rip), %rdi       # 0x22a9
movb $0x0, %al
callq 0x1050
jmp 0x1a05
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: query_rqss_numeric
static int query_rqss_numeric(char *cmd)
{
  printf("\x1bP$q%s\x1b\\", cmd);

  char *s = NULL;
  do {
    if(s)
      free(s);
    s = read_dcs();

    if(!s)
      return -1;
    if(strlen(s) < strlen(cmd))
      return -1;
    if(strcmp(s + strlen(s) - strlen(cmd), cmd) != 0) {
      printf("No match\n");
      continue;
    }

    if(s[0] != '1' || s[1] != '$' || s[2] != 'r')
      return -1;

    int num;
    if(sscanf(s + 3, "%d", &num) != 1)
      return -1;

    return num;
  } while(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x85e(%rip), %rdi       # 0x22e5
movb $0x0, %al
callq 0x1050
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1aa6
movq -0x18(%rbp), %rdi
callq 0x1030
callq 0x1df0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ac2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bb0
movq -0x18(%rbp), %rdi
callq 0x1040
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1af0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bb0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1060
cmpl $0x0, %eax
je 0x1b45
leaq 0x7b2(%rip), %rdi       # 0x22ee
movb $0x0, %al
callq 0x1050
jmp 0x1ba4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x1b6b
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x24, %eax
jne 0x1b6b
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x72, %eax
je 0x1b74
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bb0
movq -0x18(%rbp), %rdi
addq $0x3, %rdi
leaq 0x775(%rip), %rsi       # 0x22f8
leaq -0x1c(%rbp), %rdx
movb $0x0, %al
callq 0x1090
cmpl $0x1, %eax
je 0x1b9c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bb0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bb0
movb $0x1, %al
testb $0x1, %al
jne 0x1a96
jmp 0x1bb0
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: getvalue
static char *getvalue(int *argip, int argc, char *argv[])
{
  if(*argip >= argc) {
    fprintf(stderr, "Expected an option value\n");
    exit(1);
  }

  return argv[(*argip)++];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x1c00
movq 0x2413(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x70c(%rip), %rsi       # 0x22fb
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10d0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nop