LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: gen_stats
void
gen_stats(void)
{	int i;
	int cnt;

	for (i = cnt = 0; i < 5; i++)
		if (hit_cmds[i])
			cnt++;
	if (cnt)
	{	printf("uno: commands in property executed\n");
		for (i = 0; i < 5; i++)
			if (hit_cmds[i])
			printf("\t%d\t%s\n", hit_cmds[i], cmds[i].cmd);
	}
	for (i = cnt = 0; i < 5; i++)
		if (hit_cmds[i])
			cnt++;
	if (cnt)
	{	printf("uno: fcts in property executed\n");
		for (i = 0; i < 3; i++)
			if (hit_fcts[i])
			printf("\t%d\t%s\n", hit_fcts[i], evals[i].cmd);
	}

	prop_reached(uno_prop);

	if (ruledout)
	printf("uno: %3d errorpaths generated, but ruled out as infeasible\n",
		ruledout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x2f2d3
movslq -0x4(%rbp), %rcx
leaq 0x678d9(%rip), %rax     # 0x96b90
cmpl $0x0, (%rax,%rcx,4)
je 0x2f2c6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2f2c8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f2a6
cmpl $0x0, -0x8(%rbp)
je 0x2f345
leaq 0x17b14(%rip), %rdi     # 0x46df4
movb $0x0, %al
callq 0x30f0
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x2f343
movslq -0x4(%rbp), %rcx
leaq 0x67891(%rip), %rax     # 0x96b90
cmpl $0x0, (%rax,%rcx,4)
je 0x2f336
movslq -0x4(%rbp), %rcx
leaq 0x67880(%rip), %rax     # 0x96b90
movl (%rax,%rcx,4), %esi
movslq -0x4(%rbp), %rcx
leaq 0x1eed2(%rip), %rax     # 0x4e1f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x17ae9(%rip), %rdi     # 0x46e18
movb $0x0, %al
callq 0x30f0
jmp 0x2f338
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f2ee
jmp 0x2f345
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x2f380
movslq -0x4(%rbp), %rcx
leaq 0x6782c(%rip), %rax     # 0x96b90
cmpl $0x0, (%rax,%rcx,4)
je 0x2f373
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2f375
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f353
cmpl $0x0, -0x8(%rbp)
je 0x2f3f2
leaq 0x17a93(%rip), %rdi     # 0x46e20
movb $0x0, %al
callq 0x30f0
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x2f3f0
movslq -0x4(%rbp), %rcx
leaq 0x67804(%rip), %rax     # 0x96bb0
cmpl $0x0, (%rax,%rcx,4)
je 0x2f3e3
movslq -0x4(%rbp), %rcx
leaq 0x677f3(%rip), %rax     # 0x96bb0
movl (%rax,%rcx,4), %esi
movslq -0x4(%rbp), %rcx
leaq 0x1ee95(%rip), %rax     # 0x4e260
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x17a3c(%rip), %rdi     # 0x46e18
movb $0x0, %al
callq 0x30f0
jmp 0x2f3e5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f39b
jmp 0x2f3f2
leaq 0x56c07(%rip), %rax     # 0x86000
movq (%rax), %rdi
callq 0x2f430
cmpl $0x0, 0x677c8(%rip)     # 0x96bd0
je 0x2f41e
movl 0x677c0(%rip), %esi     # 0x96bd0
leaq 0x17a29(%rip), %rdi     # 0x46e40
movb $0x0, %al
callq 0x30f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: prop_reached
static void
prop_reached(State *s)
{	Trans *t;

	if (!s || !s->n) return;

	if (!s->visited
	&&  !strstr(s->n->hdr.fnm, " after "))
		printf("uno: %s:%d: not reached\n",
			s->n->hdr.fnm, s->n->hdr.line);

	s->visited = 1;	/* prevent duplicate reports */

	for (t = s->succ; t && t->branch; t = t->nxt)
		prop_reached(t->branch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2f44d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2f452
jmp 0x2f4f2
movq -0x8(%rbp), %rax
cmpw $0x0, 0x4a(%rax)
jne 0x2f49d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x17ef7(%rip), %rsi     # 0x47366
callq 0x3240
cmpq $0x0, %rax
jne 0x2f49d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edx
leaq 0x17ed8(%rip), %rdi     # 0x4736e
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movw $0x1, 0x4a(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x2f4ce
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2f4d7
jmp 0x2f4f2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2f430
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2f4b3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: get_state_val
int
get_state_val(void)
{
	if (!gen_stack)
	{	nogood = 1;
		return 0;
	}
	return gen_stack->uno_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x676cc(%rip)     # 0x96bd8
jne 0x2f524
leaq 0x675e3(%rip), %rax     # 0x96af8
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2f531
movq 0x676ad(%rip), %rax     # 0x96bd8
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: has_ident
static int
has_ident(treenode *n, char *s)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT)
		return (strcmp(((leafnode *)n)->data.sval->str, s) == 0);

	if (n->hdr.which != LEAF_T)
		switch (n->hdr.type) {
		case TN_SWITCH:
		case TN_WHILE:
		case TN_DOWHILE:
			return has_ident(n->lnode, s);
		default:
			return has_ident(n->lnode, s) || has_ident(n->rnode, s);
		}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f9e3
movl $0x0, -0x4(%rbp)
jmp 0x2fa8d
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2fa12
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2fa8d
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x2fa86
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
addl $-0x1f, %eax
subl $0x2, %eax
ja 0x2fa42
jmp 0x2fa2c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f9c0
movl %eax, -0x4(%rbp)
jmp 0x2fa8d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f9c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x2fa79
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f9c0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2fa8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: ref_args
static int
ref_args(treenode *e, treenode *n)	/* 1: refine(with,without), 2: unselect(with,without) */
{	treenode *f;
	int val1, val2;

	/*	   TN_FUNC_CALL:e
		      /    \
		     /      \
		TN_IDENT  TN_EXPR_LIST:f
		   /          /         \
		refine       /       TN_INT:val2
		     TN_INT:val1
	 */
		if (!e->rnode
		||   e->rnode->hdr.type != TN_EXPR_LIST)
			goto bad1;
	f = e->rnode;
		if (!f->lnode || !f->rnode)
			goto bad1;
	nogood = 0;
	val1 = eval_const_expr(f->lnode, n);
	val2 = eval_const_expr(f->rnode, n);
	if (nogood)
	{
bad1:		err_path++;
		fprintf(stderr, "\t\t%s:%d: error in args in '%s'\n",
			n?n->hdr.fnm:"--", n?n->hdr.line:0, x_stmnt(e));
		exit(1);
	}

	if (debug)
	printf(">>saw %s(%s,%d,%d,%d)\n", x_stmnt(e), user_name, user_val, val1, val2);

	return doref(n, val1, val2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2fcd9
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0xa, 0x1c(%rax)
je 0x2fcdb
jmp 0x2fd46
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2fcfd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2fcff
jmp 0x2fd46
leaq 0x66df2(%rip), %rax     # 0x96af8
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b4f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b4f0
movl %eax, -0x20(%rbp)
leaq 0x66dbd(%rip), %rax     # 0x96af8
cmpl $0x0, (%rax)
je 0x2fddc
jmp 0x2fd46
movl 0x66e94(%rip), %eax     # 0x96be0
addl $0x1, %eax
movl %eax, 0x66e8b(%rip)     # 0x96be0
movq 0x1e29c(%rip), %rax     # 0x4dff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fd78
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2fd85
leaq 0x548c(%rip), %rax      # 0x3520b
movq %rax, -0x30(%rbp)
jmp 0x2fd85
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fda0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x2fda7
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2fda7
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ec0
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl -0x40(%rbp), %ecx
movq %rax, %r8
leaq 0x17622(%rip), %rsi     # 0x473ed
movb $0x0, %al
callq 0x3170
movl $0x1, %edi
callq 0x3230
cmpl $0x0, 0x66e05(%rip)     # 0x96be8
je 0x2fe14
movq -0x8(%rbp), %rdi
callq 0x4ec0
movq %rax, %rsi
movq 0x66df8(%rip), %rdx     # 0x96bf0
movl 0x66dee(%rip), %ecx     # 0x96bec
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
leaq 0x17600(%rip), %rdi     # 0x4740d
movb $0x0, %al
callq 0x30f0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x321b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: gen_push
static int
gen_push(State *s)
{	GenStack *g;
	SymRef *r, *t;
	int any_added = 0;

	if (gen_free)
	{	g = gen_free;
		gen_free = gen_free->nxt;
	} else
		g = (GenStack *) emalloc(sizeof(GenStack));

	if (gen_stack)
	{	g->uno_state = gen_stack->uno_state;	/* copy state-bits */

		for (r = gen_stack->symrefs; r; r = r->nxt)
		{	if (snap_add(s, r))		/* not tracked from s before */
				any_added = 1;

			t = uno_getref(r->sm);
			t->status = r->status;
			t->s_val = r->s_val;
			t->n = r->n;
			t->nxt = g->symrefs;
			g->symrefs = t;
	}	}

	g->nxt = gen_stack;
	gen_stack = g;

	return any_added;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, 0x66755(%rip)     # 0x96c00
je 0x304cc
movq 0x6674c(%rip), %rax     # 0x96c00
movq %rax, -0x10(%rbp)
movq 0x66741(%rip), %rax     # 0x96c00
movq 0x20(%rax), %rax
movq %rax, 0x66736(%rip)     # 0x96c00
jmp 0x304da
movl $0x28, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x666f6(%rip)     # 0x96bd8
je 0x30594
movq 0x666e9(%rip), %rax     # 0x96bd8
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x666d8(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x30592
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20610
cmpl $0x0, %eax
je 0x3052b
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x20420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x30507
jmp 0x30594
movq 0x6663d(%rip), %rcx     # 0x96bd8
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x6662a(%rip)     # 0x96bd8
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: exec_prop
static void
exec_prop(State *s, treenode *n)
{	treenode *exp = ZT;
	State *ns = ZS;

	if (!s) return;

	if (debug) printf("exec_prop %s:%d: %s <%s>\n",
			s->n->hdr.fnm,
			s->n->hdr.line,
			name_of_node(s->n->hdr.type),
			x_stmnt(s->n));

	s->visited = 1;	/* to determine effective coverage of property */

	if (s->iscond && s->n)
	{	exp = (s->n->hdr.type == TN_IF) ? ((if_node *)s->n)->cond : s->n;
		ns = exec_lastfirst(s, s->succ, exp, n);	/* eval_step(exp) */
	} else
	{	exec_step(s->n, n);
		if (s->succ) ns = s->succ->branch;
	}

	exec_prop(ns, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x305ec
jmp 0x306f7
cmpl $0x0, 0x665f5(%rip)     # 0x96be8
je 0x3064c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %edi
callq 0x8270
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4ec0
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0x16ebf(%rip), %rdi     # 0x47504
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movw $0x1, 0x4a(%rax)
movq -0x8(%rbp), %rax
movswl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x306bd
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x306bd
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x3068b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x30696
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x324c0
movq %rax, -0x20(%rbp)
jmp 0x306ea
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x325f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x306e8
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x306ea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x305c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: gen_pop
static void
gen_pop(GenStack *g)
{
	g->symrefs = rev_release(g->symrefs);
	g->uno_state = 0;

	uno_assert((gen_stack != NULL), "gen_stack error");

	gen_stack = gen_stack->nxt;	/* pop stack */
	g->nxt = gen_free;
	gen_free = g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x20300
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
cmpq $0x0, 0x664a3(%rip)     # 0x96bd8
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1723f(%rip), %rsi     # 0x47983
callq 0x1fde0
movq 0x66488(%rip), %rax     # 0x96bd8
movq 0x20(%rax), %rax
movq %rax, 0x6647d(%rip)     # 0x96bd8
movq 0x6649e(%rip), %rcx     # 0x96c00
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x6648b(%rip)     # 0x96c00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_del
static void
sym_del(treenode *m, int allow, int forbid)
{	SymRef *s, *os;
	SymList *r;
	treenode *n;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if ((r->mark & allow) && !(r->mark & forbid))
		{	os = (SymRef *) 0;
again:			for (s = gen_stack->symrefs; s; os = s, s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0
				&&  (s->status & allow)
				&& !(s->status & forbid))
				{	if (!os)
						gen_stack->symrefs = s->nxt;
					else
						os->nxt = s->nxt;

					if (debug) printf("\tdeleted %s\n",
						s->sm->nme->str);

					goto again;
	}	}	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30a31
movq -0x8(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x30a31
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x30a39
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x30b8c
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x30b8c
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30b8a
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x30b77
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x30b77
movq $0x0, -0x20(%rbp)
movq 0x6612d(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x30b75
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x30b5a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x30b5a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x30b5a
cmpq $0x0, -0x20(%rbp)
jne 0x30b1f
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x660be(%rip), %rax     # 0x96bd8
movq %rcx, (%rax)
jmp 0x30b2f
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, 0x660b2(%rip)     # 0x96be8
je 0x30b55
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x164dd(%rip), %rdi     # 0x4702b
movb $0x0, %al
callq 0x30f0
jmp 0x30aa4
jmp 0x30b5c
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x30ab2
jmp 0x30b77
jmp 0x30b79
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x30a6b
jmp 0x30b8c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: list_select
static void
list_select(treenode *n, int unused1, int unused2)
{	SymRef *s;
	SymList *r;
	int cnt = 0;

	if (n)
		printf("uno: %s:%d: symbols (*=selected):\n",
			n->hdr.fnm, n->hdr.line);
	else
		printf("uno: symbols (*=selected):\n");

	for (s = gen_stack->symrefs; s; s = s->nxt)
		{	printf("	%3d%s:\t%s [",
				++cnt,
				(s->status & SELECTED)?"*":"",
				s->sm->nme->str);
			dflow_mark(stdout, s->status);
			printf("]	(stack - mark %d)\n", s->s_val);
		}

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		{	printf("	%3d%s:	%s [",
				++cnt,
				r->selected?"*":"",
				r->sm->nme->str);
			dflow_mark(stdout, r->mark);
			printf("]	(stmnt)\n");
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30d6f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x162d2(%rip), %rdi     # 0x47038
movb $0x0, %al
callq 0x30f0
jmp 0x30d7d
leaq 0x162e5(%rip), %rdi     # 0x4705b
movb $0x0, %al
callq 0x30f0
movq 0x65e54(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x30e1a
movl -0x24(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
leaq 0x4002(%rip), %rdx      # 0x34db5
leaq 0x43fa(%rip), %rax      # 0x351b4
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x162a0(%rip), %rdi     # 0x47077
movb $0x0, %al
callq 0x30f0
movq 0x1d1eb(%rip), %rax     # 0x4dfd0
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x1b330
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x16282(%rip), %rdi     # 0x47084
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x30d8b
cmpq $0x0, -0x8(%rbp)
je 0x30ec1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x30ec1
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30ebf
movl -0x24(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
leaq 0x3f54(%rip), %rdx      # 0x34db5
leaq 0x434c(%rip), %rax      # 0x351b4
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x161f1(%rip), %rdi     # 0x47077
movb $0x0, %al
callq 0x30f0
movq 0x1d13c(%rip), %rax     # 0x4dfd0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1b330
leaq 0x161ef(%rip), %rdi     # 0x47099
movb $0x0, %al
callq 0x30f0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x30e44
jmp 0x30ec1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_unmark
static void
sym_unmark(treenode *unused0, int unused1, int unused2)
{	SymRef *s, *os = (SymRef *) 0;

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
		{	if (!os)
				gen_stack->symrefs = s->nxt;
			else
				os->nxt = s->nxt;

			if (debug) fprintf(stderr, "\tdeleted %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
		} else
			os = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x65ab7(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x311f8
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x311dd
cmpq $0x0, -0x20(%rbp)
jne 0x31163
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x65a7a(%rip), %rax     # 0x96bd8
movq %rcx, (%rax)
jmp 0x31173
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, 0x65a6e(%rip)     # 0x96be8
je 0x311db
movq 0x1ce75(%rip), %rax     # 0x4dff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x311b8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x311c2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x311c2
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %ecx
leaq 0x15eeb(%rip), %rsi     # 0x470bf
movb $0x0, %al
callq 0x3170
jmp 0x311e5
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x311e7
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x31128
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: any_track
static int
any_track(treenode *m, int allow, int forbid)
{	SymRef *s;

	for (s = gen_stack->symrefs; s; s = s->nxt)
	{	if ((s->status & allow)
		&& !(s->status & forbid))
		{	if (m != s->n)
				witness = s->n;
			if (debug) printf("\tanytrack sym present %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
			return 1;
	}	}

	if (debug) printf("any_track: no matching syms\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x6572f(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3156c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x31559
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
jne 0x31559
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x314fa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x656fe(%rip)     # 0x96bf8
cmpl $0x0, 0x656e7(%rip)     # 0x96be8
je 0x31550
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x31531
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3153b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x3153b
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x15c26(%rip), %rdi     # 0x4716f
movb $0x0, %al
callq 0x30f0
movl $0x1, -0x4(%rbp)
jmp 0x3158a
jmp 0x3155b
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x314b0
cmpl $0x0, 0x65675(%rip)     # 0x96be8
je 0x31583
leaq 0x15c17(%rip), %rdi     # 0x47193
movb $0x0, %al
callq 0x30f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: match_track
static int
match_track(treenode *m, int allow, int forbid)
{	SymRef *s;
	SymList *r;
	treenode *n;	/* var with allow and !forbid on defuse - that is also on_track? */

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		if ((r->mark & allow) && !(r->mark & forbid))
		{	for (s = gen_stack->symrefs; s; s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0)
				{	if (m != s->n)
						witness = s->n;
					if (debug) printf("\tsym matched %s (line %d)\n",
						r->sm->nme->str, s->n?s->n->hdr.line:-1);
					return 1;
		}	}	}

	if (debug) printf("match_track: no matching syms\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x315d1
movq -0x10(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x315d1
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x315d9
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x31725
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31725
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x31723
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x31710
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
jne 0x31710
movq 0x65595(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3170e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x316fb
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x3169b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x6555d(%rip)     # 0x96bf8
cmpl $0x0, 0x65546(%rip)     # 0x96be8
je 0x316f2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x316d3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x316dd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x44(%rbp)
jmp 0x316dd
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
leaq 0x15ac5(%rip), %rdi     # 0x471b0
movb $0x0, %al
callq 0x30f0
movl $0x1, -0x4(%rbp)
jmp 0x31743
jmp 0x316fd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3164a
jmp 0x31710
jmp 0x31712
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3160b
jmp 0x31725
cmpl $0x0, 0x654bc(%rip)     # 0x96be8
je 0x3173c
leaq 0x15a96(%rip), %rdi     # 0x471cb
movb $0x0, %al
callq 0x30f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: good_target
static int
good_target(treenode *n, SymList *r)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT) return 1;

	if (n->hdr.type == TN_ASSIGN
	&&  n->lnode
	&&  n->lnode->hdr.type == TN_IDENT
	&&  strcmp(r->sm->nme->str, ((leafnode *) n->lnode)->data.sval->str) == 0)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31f20
movl $0x0, -0x4(%rbp)
jmp 0x31f90
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x31f33
movl $0x1, -0x4(%rbp)
jmp 0x31f90
movq -0x10(%rbp), %rax
cmpl $0x1c, 0x1c(%rax)
jne 0x31f89
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x31f89
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x31f89
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x31f89
movl $0x1, -0x4(%rbp)
jmp 0x31f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: doref
static int
doref(treenode *m, int allow, int forbid)	/* refine -- unselect nonmatches */
{	SymList *r;
	treenode *n;
	int nonempty = 0;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if (debug)
		printf(">> refine/unselect saw: %s mark=%d\n",
			r->sm->nme->str, r->mark);

		if (r->selected)
		{	if (!(r->mark & allow)
			||   (r->mark & forbid))
				r->selected = 0;
			else
				nonempty = 1;
	}	}

	return nonempty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x321e8
movq -0x8(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x321e8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x321f0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x322a8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x322a8
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x322a6
cmpl $0x0, 0x649b8(%rip)     # 0x96be8
je 0x32257
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x151d4(%rip), %rdi     # 0x47424
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32293
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x3227e
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x3228a
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x32291
movl $0x1, -0x24(%rbp)
jmp 0x32293
jmp 0x32295
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x32222
jmp 0x322a8
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: exec_lastfirst
static State *
exec_lastfirst(State *s, Trans *t, treenode *e, treenode *n)
{	State *x;

	if (!t || !t->branch)
	{	if (debug>1) printf("\t(%d) lastfirst. no branch\n", s->n->hdr.line);
		return ZS;
	}

	if ((x = exec_lastfirst(s, t->nxt, e, n)) != NULL)	/* assign x */
	{	if (debug>1) printf("\t(%d) lastfirst. gottcha\n", s->n->hdr.line);
		return x;
	}

	if (e && !eval_step(e, t->cond, n))
	{	if (debug>1) printf("\t(%d) lastfirst. fail eval\n", s->n->hdr.line);
		return ZS;
	}

	if (debug>1) printf("\t(%d) lastfirst. pass eval\n", s->n->hdr.line);

	return t->branch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x324ea
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x32518
cmpl $0x1, 0x646f7(%rip)     # 0x96be8
jle 0x3250b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x1501a(%rip), %rdi     # 0x4751e
movb $0x0, %al
callq 0x30f0
movq $0x0, -0x8(%rbp)
jmp 0x325de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x324c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x32566
cmpl $0x1, 0x646a6(%rip)     # 0x96be8
jle 0x3255c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x14fe5(%rip), %rdi     # 0x4753a
movb $0x0, %al
callq 0x30f0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x325de
cmpq $0x0, -0x20(%rbp)
je 0x325b1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x328e0
cmpl $0x0, %eax
jne 0x325b1
cmpl $0x1, 0x6465b(%rip)     # 0x96be8
jle 0x325a7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x14fb4(%rip), %rdi     # 0x47554
movb $0x0, %al
callq 0x30f0
movq $0x0, -0x8(%rbp)
jmp 0x325de
cmpl $0x1, 0x64630(%rip)     # 0x96be8
jle 0x325d2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x14fa5(%rip), %rdi     # 0x47570
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: do_oper
static int
do_oper(treenode *m, int sign)
{	treenode *n;

	/* either --x (rnode) or x-- (lnode) */
	/* executed as stmnt, net effect the same */

	if (m->rnode) n = m->rnode; else n = m->lnode;

	if (!n
	||   n->hdr.type != TN_IDENT
	||  strcmp(((leafnode *) n)->data.sval->str, statename) != 0)
		return 0;

	gen_stack->uno_state += sign;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x33328
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x33334
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x33362
movq -0x20(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x33362
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x1ae90(%rip), %rsi     # 0x4e1e8
callq 0x3160
cmpl $0x0, %eax
je 0x3336b
movl $0x0, -0x4(%rbp)
jmp 0x33382
movl -0x14(%rbp), %ecx
movq 0x63863(%rip), %rax     # 0x96bd8
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_matched
static int
err_matched(GenStack *g)
{
	if (!g) return 0;

	return err_matched(g->nxt)
	|| (witness
	&&  witness == g->e
	&&  v_matched(g->e));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3391c
movl $0x0, -0x4(%rbp)
jmp 0x33981
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33900
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x33976
xorl %eax, %eax
cmpq $0x0, 0x632b9(%rip)     # 0x96bf8
movb %al, -0x12(%rbp)
je 0x33970
movq 0x632ad(%rip), %rcx     # 0x96bf8
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x12(%rbp)
jne 0x33970
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2b870
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: selected_symbol
static void
selected_symbol(treenode *n)
{	SymRef *s;
	SymList *r;

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
			printf(" [%s]", s->sm->nme->str);

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if (!r->selected)
			continue;

		for (s = gen_stack->symrefs; s; s = s->nxt)
		{	if (s->status & SELECTED
			&&  strcmp(s->sm->nme->str, r->sm->nme->str) == 0)
				break;
		}
		if (!s) printf(" [%s]", r->sm->nme->str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x63235(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x339ef
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x339df
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x13f7c(%rip), %rdi     # 0x47954
movb $0x0, %al
callq 0x30f0
jmp 0x339e1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x339aa
cmpq $0x0, -0x8(%rbp)
je 0x33acd
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x33acd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x33acb
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x33a32
jmp 0x33aba
movq 0x6319f(%rip), %rax     # 0x96bd8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x33a93
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x33a83
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x33a83
jmp 0x33a93
jmp 0x33a85
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x33a40
cmpq $0x0, -0x10(%rbp)
jne 0x33ab8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x13ea3(%rip), %rdi     # 0x47954
movb $0x0, %al
callq 0x30f0
jmp 0x33aba
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x33a19
jmp 0x33acd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_reversed
static void
err_reversed(GenStack *g)
{
	if (!g) return;

	if (!nopaths)
		err_reversed(g->nxt);
#if 0
	if (!debug && witness)
	{	if (g->e != witness)
			return;
		if (v_reported(g->e))
		{	fprintf(stderr, "\t--:\t%s:%d: <%s> matches an earlier case\n",
				g->e->hdr.fnm,
				g->e->hdr.line,
				x_stmnt(g->e));
			return;
		}
	}
	witness = ZT;
#endif

	if (g->e
	&&  g->e->hdr.type != TN_SWITCH
	&&  g->e->hdr.type != TN_WHILE
	&&  g->e->hdr.type != TN_DOWHILE)
	{
		if (g->e == witness) printf("*");
		if (g->c) printf("C");

		if (!nopaths) printf("\t%d:", steps++);

		printf("\t%s:%d: <%s>",
			g->e->hdr.fnm,
			g->e->hdr.line,
			x_stmnt(g->e));
		if (g->c)
			printf(" == <%s>", x_stmnt(g->c));

		if (debug) dump_defuse(g->e->hdr.defuse, stdout);
		printf(";\n");
	} else if (nopaths) err_reversed(g->nxt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x33af8
jmp 0x33c74
leaq 0x1a645(%rip), %rax     # 0x4e144
cmpl $0x0, (%rax)
jne 0x33b11
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33ae0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x33c59
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x21, 0x1c(%rax)
je 0x33c59
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1f, 0x1c(%rax)
je 0x33c59
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x20, 0x1c(%rax)
je 0x33c59
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x63093(%rip), %rax     # 0x96bf8
jne 0x33b75
leaq 0x1646(%rip), %rdi      # 0x351b4
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x33b8e
leaq 0x10068(%rip), %rdi     # 0x43bef
movb $0x0, %al
callq 0x30f0
leaq 0x1a5af(%rip), %rax     # 0x4e144
cmpl $0x0, (%rax)
jne 0x33bb9
movl 0x6306c(%rip), %esi     # 0x96c0c
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x63061(%rip)     # 0x96c0c
leaq 0x13da8(%rip), %rdi     # 0x4795a
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4ec0
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movq %rax, %rcx
leaq 0x13d6a(%rip), %rdi     # 0x4795f
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x33c25
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4ec0
movq %rax, %rsi
leaq 0x13d4e(%rip), %rdi     # 0x4796c
movb $0x0, %al
callq 0x30f0
cmpl $0x0, 0x62fbc(%rip)     # 0x96be8
je 0x33c49
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rdi
movq 0x1a38f(%rip), %rax     # 0x4dfd0
movq (%rax), %rsi
callq 0x1a7b0
leaq 0xcc5(%rip), %rdi       # 0x34915
movb $0x0, %al
callq 0x30f0
jmp 0x33c74
leaq 0x1a4e4(%rip), %rax     # 0x4e144
cmpl $0x0, (%rax)
je 0x33c72
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33ae0
jmp 0x33c74
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_module
static void _ir_module(IRGeneratorContext *ctx, ParserASTNode *node) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_MODULE);

	for (int i = 0; i < node->nchilds; i++) {
		_ir_module_item(ctx, node->childs[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf649
jmp 0xf668
leaq 0x6cf06(%rip), %rdi     # 0x7c556
leaq 0x64d3d(%rip), %rsi     # 0x74394
movl $0x133f, %edx           # imm = 0x133F
leaq 0x64e8e(%rip), %rcx     # 0x744f1
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0xf671
jmp 0xf690
leaq 0x6695b(%rip), %rdi     # 0x75fd3
leaq 0x64d15(%rip), %rsi     # 0x74394
movl $0x1340, %edx           # imm = 0x1340
leaq 0x64e66(%rip), %rcx     # 0x744f1
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0xf69e
jmp 0xf6bd
leaq 0x64e83(%rip), %rdi     # 0x74528
leaq 0x64ce8(%rip), %rsi     # 0x74394
movl $0x1341, %edx           # imm = 0x1341
leaq 0x64e39(%rip), %rcx     # 0x744f1
callq 0x30a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xf6f4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xfa60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6c4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: fe_irgen_new_context
IRGeneratorContext * fe_irgen_new_context(ParserContext *psrctx, FILE *out) {
	assert(psrctx);
	assert(psrctx->ast);
	assert(out);
	
	IRGeneratorContext *ctx = (IRGeneratorContext *)malloc(sizeof(IRGeneratorContext));
	if (ctx == NULL) {
		_error("cannot allocate memory for a new context!");
	}

	ctx->psrctx = psrctx;
	ctx->out = out;

	ctx->global = rstr_new();
	ctx->head = rstr_new();
	ctx->body = rstr_new();
	ctx->foot = rstr_new();
	ctx->local_var_defs = NULL;

	rstr_init(ctx->global);
	rstr_init(ctx->head);
	rstr_init(ctx->body);
	rstr_init(ctx->foot);

	ctx->counter = 0;
	ctx->func_symbol = NULL;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf719
jmp 0xf738
leaq 0x64cc0(%rip), %rdi     # 0x743e0
leaq 0x64c6d(%rip), %rsi     # 0x74394
movl $0x135c, %edx           # imm = 0x135C
leaq 0x64cf7(%rip), %rcx     # 0x7442a
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf745
jmp 0xf764
leaq 0x64ca0(%rip), %rdi     # 0x743ec
leaq 0x64c41(%rip), %rsi     # 0x74394
movl $0x135d, %edx           # imm = 0x135D
leaq 0x64ccb(%rip), %rcx     # 0x7442a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0xf76d
jmp 0xf78c
leaq 0x64cb2(%rip), %rdi     # 0x74426
leaq 0x64c19(%rip), %rsi     # 0x74394
movl $0x135e, %edx           # imm = 0x135E
leaq 0x64ca3(%rip), %rcx     # 0x7442a
callq 0x30a0
movl $0x48, %edi
callq 0x3120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf7ad
leaq 0x64cc4(%rip), %rdi     # 0x7446c
callq 0xf870
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x91e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x91e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0x91e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x91e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8c90
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8c90
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8c90
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8c90
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: fe_irgen_free_context
void fe_irgen_free_context(IRGeneratorContext *ctx) {
	assert(ctx);
	assert(ctx->global);
	assert(ctx->head);
	assert(ctx->body);
	assert(ctx->foot);

	rstr_free(ctx->global);
	rstr_free(ctx->head);
	rstr_free(ctx->body);
	rstr_free(ctx->foot);

	free(ctx->global);
	free(ctx->head);
	free(ctx->body);
	free(ctx->foot);

	ctx->global = NULL;
	ctx->head = NULL;
	ctx->body = NULL;
	ctx->foot = NULL;

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf8e5
jmp 0xf904
leaq 0x6cc6a(%rip), %rdi     # 0x7c556
leaq 0x64aa1(%rip), %rsi     # 0x74394
movl $0x137a, %edx           # imm = 0x137A
leaq 0x64b97(%rip), %rcx     # 0x74496
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf911
jmp 0xf930
leaq 0x64baf(%rip), %rdi     # 0x744c7
leaq 0x64a75(%rip), %rsi     # 0x74394
movl $0x137b, %edx           # imm = 0x137B
leaq 0x64b6b(%rip), %rcx     # 0x74496
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf93d
jmp 0xf95c
leaq 0x64b8f(%rip), %rdi     # 0x744d3
leaq 0x64a49(%rip), %rsi     # 0x74394
movl $0x137c, %edx           # imm = 0x137C
leaq 0x64b3f(%rip), %rcx     # 0x74496
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf969
jmp 0xf988
leaq 0x64b6d(%rip), %rdi     # 0x744dd
leaq 0x64a1d(%rip), %rsi     # 0x74394
movl $0x137d, %edx           # imm = 0x137D
leaq 0x64b13(%rip), %rcx     # 0x74496
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xf995
jmp 0xf9b4
leaq 0x64b4b(%rip), %rdi     # 0x744e7
leaq 0x649f1(%rip), %rsi     # 0x74394
movl $0x137e, %edx           # imm = 0x137E
leaq 0x64ae7(%rip), %rcx     # 0x74496
callq 0x30a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9310
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x9310
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9310
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9310
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x31a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)