LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: prevpathcond
static void
prevpathcond(void)
{	PathCond *np;

	np = pathcond;
	pathcond = pathcond->nxt;	/* uno cannot exclude nill-deref here */
	np->nxt = pathfree;
	pathfree = np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x60bed(%rip), %rax     # 0x86098
movq %rax, -0x8(%rbp)
movq 0x60be2(%rip), %rax     # 0x86098
movq 0x10(%rax), %rax
movq %rax, 0x60bd7(%rip)     # 0x86098
movq 0x60bd8(%rip), %rcx     # 0x860a0
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x60bc5(%rip)     # 0x860a0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: dfs_pop
static void
dfs_pop(void)
{	DfStack *d;
	SymRef *r, *n;

	uno_assert((dfstack != NULL && safe_stack != NULL), "no dfstack or safe_stack");

	for (r = dfstack->symrefs; r; r = n)	/* free stack items */
	{	n = r->nxt;
		r->nxt = dfs_free;
		dfs_free = r;
	}
	for (r = dfstack->globrefs; r; r = n)
	{	n = r->nxt;
		r->nxt = dfs_free;
		dfs_free = r;
	}

	d = dfstack;
	dfstack = dfstack->nxt;
	d->nxt = dfs_frame;			/* free stackframe */
	dfs_frame = d;

	for (r = safe_stack->symrefs; r; r = n)	/* free sym refs */
	{	n = r->nxt;
		r->nxt = dfs_free;
		dfs_free = r;
	}
	d = safe_stack;
	safe_stack = safe_stack->nxt;
	d->nxt = dfs_frame;			/* free stackframe */
	dfs_frame = d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
cmpq $0x0, 0x60b9e(%rip)     # 0x86090
movb %al, -0x19(%rbp)
je 0x25505
cmpq $0x0, 0x60ba9(%rip)     # 0x860a8
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x204e7(%rip), %rsi     # 0x459fb
callq 0x1fde0
movq 0x60b70(%rip), %rax     # 0x86090
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2555e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x60a6f(%rip), %rcx     # 0x85fb0
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x60a5c(%rip)     # 0x85fb0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x25527
movq 0x60b2b(%rip), %rax     # 0x86090
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x255a4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x60a29(%rip), %rcx     # 0x85fb0
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x60a16(%rip)     # 0x85fb0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2556d
movq 0x60ae5(%rip), %rax     # 0x86090
movq %rax, -0x8(%rbp)
movq 0x60ada(%rip), %rax     # 0x86090
movq 0x18(%rax), %rax
movq %rax, 0x60acf(%rip)     # 0x86090
movq 0x60ae8(%rip), %rcx     # 0x860b0
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x60ad5(%rip)     # 0x860b0
movq 0x60ac6(%rip), %rax     # 0x860a8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25620
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x609ad(%rip), %rcx     # 0x85fb0
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x6099a(%rip)     # 0x85fb0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x255e9
movq 0x60a81(%rip), %rax     # 0x860a8
movq %rax, -0x8(%rbp)
movq 0x60a76(%rip), %rax     # 0x860a8
movq 0x18(%rax), %rax
movq %rax, 0x60a6b(%rip)     # 0x860a8
movq 0x60a6c(%rip), %rcx     # 0x860b0
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x60a59(%rip)     # 0x860b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_getframe
static DfStack *
uno_getframe(void)
{	DfStack *r;

	if (dfs_frame)
	{	r = dfs_frame;
		dfs_frame = dfs_frame->nxt;
		r->symrefs = (SymRef *) 0;
		r->globrefs = (SymRef *) 0;
		r->nxt = (DfStack *) 0;
	} else
		r = (DfStack *) emalloc(sizeof(DfStack));

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x60a40(%rip)     # 0x860b0
je 0x256b4
movq 0x60a37(%rip), %rax     # 0x860b0
movq %rax, -0x8(%rbp)
movq 0x60a2c(%rip), %rax     # 0x860b0
movq 0x18(%rax), %rax
movq %rax, 0x60a21(%rip)     # 0x860b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x256c2
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: copy_list
static SymRef *
copy_list(SymRef *s)
{	SymRef *r;

	if (!s) return (SymRef *) 0;

	r = uno_getref(s->sm);
	r->n = s->n;
	r->status = s->status;
	r->s_val = s->s_val;
	r->nxt = copy_list(s->nxt);

	return r;	/* maintains list in order */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25ded
movq $0x0, -0x8(%rbp)
jmp 0x25e49
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x20420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x25dd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: in_lst
static int
in_lst(SymRef *list, SymRef *r)
{	SymRef *q;

	for (q = list; q; q = q->nxt)
		if (q->sm == r->sm
		&&  (q->status & DEF) == (r->status & DEF))
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25ebc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x25eac
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
jne 0x25eac
movl $0x1, -0x4(%rbp)
jmp 0x25ec3
jmp 0x25eae
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x25e74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: copy_pc
static PathCond *
copy_pc(PathCond *n)
{	PathCond *r;
	PathCond *s = n;

	while (s && !relevant(s->exp))	/* ! was missing... gjh 3/19/2002 */
		s = s->nxt;

	if (!s) return (PathCond *) 0;

	r = getpathframe();
	r->exp = s->exp;
	r->val = s->val;
	r->nxt = copy_pc(s->nxt);

	return r;	/* maintains list in order */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x25f07
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x25f80
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x25f10
jmp 0x25f1e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x25ee4
cmpq $0x0, -0x20(%rbp)
jne 0x25f2f
movq $0x0, -0x8(%rbp)
jmp 0x25f76
callq 0x25450
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x25ed0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: relevant
static int
relevant(treenode *n)
{
	if (!n) return 0;

	if (n->syment
	&&  (on_glob(n->syment) || on_stack(n->syment)))
	{	if (debug)
			printf("---%s is relevant (%d)\n",
			n->syment->nme->str, on_glob(n->syment));
		return 1;
	}

	if (n->hdr.which == LEAF_T)
		return 0;

	return relevant(n->lnode) || relevant(n->rnode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25f9f
movl $0x0, -0x4(%rbp)
jmp 0x26061
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x26015
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x26070
cmpl $0x0, %eax
jne 0x25fce
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x260d0
cmpl $0x0, %eax
je 0x26015
cmpl $0x0, 0x5fffb(%rip)     # 0x85fd0
je 0x2600c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x26070
movq -0x18(%rbp), %rsi
movl %eax, %edx
leaq 0x1f5c4(%rip), %rdi     # 0x455c9
movb $0x0, %al
callq 0x30f0
movl $0x1, -0x4(%rbp)
jmp 0x26061
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x26027
movl $0x0, -0x4(%rbp)
jmp 0x26061
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x25f80
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x26056
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x25f80
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%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_lts.c
// Function: on_glob
static int
on_glob(symentry_t *t)
{	SymRef *r;

	for (r = globs; r; r = r->nxt)
		if (r->sm == t)
			return ((r->status & ~2) == 0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x5ff69(%rip), %rax     # 0x85fe8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x260c1
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x260b1
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl $-0x3, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x260c8
jmp 0x260b3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x26083
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: on_stack
static int
on_stack(symentry_t *t)		/* locals only */
{	SymRef *r;

	if (dfstack)
	for (r = dfstack->symrefs; r; r = r->nxt)
		if (r->sm == t)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x5ffb0(%rip)     # 0x86090
je 0x2611f
movq 0x5ffa7(%rip), %rax     # 0x86090
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2611d
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2610d
movl $0x1, -0x4(%rbp)
jmp 0x26126
jmp 0x2610f
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x260f0
jmp 0x2611f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: mark_guse
static void
mark_guse(symentry_t *t, treenode *n, int stc)
{	SymRef *r;

	if (0)
	printf("mark_guse: %s:%d: - %s - %d\n", n->hdr.fnm, n->hdr.line, t->nme->str, stc);

	if (is_enum_const(t)) return;

	for (r = globuse; r; r = r->nxt)
		if (r->sm == t)
		{	r->status |= stc;
			return;
		}

	r = uno_getref(t);
	r->status = stc;
	r->n = n;
	r->nxt = globuse;
	globuse = r;
#if 0
	/* 128 - array_decl, 64 - fct param, 2 - static, 4 - extern */
	if (show_sharing && !(stc&64) && ((stc&4) || !(stc&2)))
		printf("%s:%d:\t%s\t\t%s\n",
			n->hdr.fnm, n->hdr.line, t->nme->str,
			(stc&4)?"imported":"exported");
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5950
cmpl $0x0, %eax
je 0x27103
jmp 0x2717e
movq 0x5eee6(%rip), %rax     # 0x85ff0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27141
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x27131
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x2717e
jmp 0x27133
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2710e
movq -0x8(%rbp), %rdi
callq 0x20420
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x5ee85(%rip), %rcx     # 0x85ff0
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x5ee72(%rip)     # 0x85ff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_glob
static void
add_glob(symentry_t *t, treenode *n, int stc)
{	SymRef *r;

	if (debug) printf("Adding Global %s to globs\n", t->nme->str);

	for (r = globs; r; r = r->nxt)
		if (r->sm == t)
		{	r->status |= stc;
			return;
		}

	r = uno_getref(t);
	r->n = n;
	r->status = stc;
	r->nxt = globs;
	globs = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0x5ee26(%rip)     # 0x85fd0
je 0x271c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1e52b(%rip), %rdi     # 0x456ea
movb $0x0, %al
callq 0x30f0
movq 0x5ee1b(%rip), %rax     # 0x85fe8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27204
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x271f4
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x27241
jmp 0x271f6
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x271d1
movq -0x8(%rbp), %rdi
callq 0x20420
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 0x5edba(%rip), %rcx     # 0x85fe8
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x5eda7(%rip)     # 0x85fe8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: on_safe
static int
on_safe(symentry_t *t)
{	SymRef *r;

	if (safe_stack)
	for (r = safe_stack->symrefs; r; r = r->nxt)
		if (r->sm == t)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x5ebf8(%rip)     # 0x860a8
je 0x274ef
movq 0x5ebef(%rip), %rax     # 0x860a8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x274ed
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x274dd
movl $0x1, -0x4(%rbp)
jmp 0x274f6
jmp 0x274df
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x274c0
jmp 0x274ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_safe
static void
add_safe(symentry_t *t, treenode *n)
{	SymRef *r;

	r = uno_getref(t);
	r->n = n;
	r->nxt = safe_stack->symrefs;
	safe_stack->symrefs = r;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x5eb78(%rip), %rax     # 0x860a8
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq 0x5eb62(%rip), %rax     # 0x860a8
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_uses
static void
add_uses(symentry_t *t, treenode *n)
{
	mark_defuse(t, n, USE);

	if (!on_glob(t))
	{	make_suspect(t, n, USE);	/* use of non-ptrs only */
		attach_nut("U", t, n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x27890
movq -0x8(%rbp), %rdi
callq 0x26070
cmpl $0x0, %eax
jne 0x27826
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x28010
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1e317(%rip), %rdi     # 0x45b38
callq 0x26f00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_derefs
static void
add_derefs(symentry_t *t, treenode *n)
{
	mark_defuse(t, n, USE|DEREF);
	if (on_glob(t))
	{	make_suspect(t, n, USE|DEREF);	/* pointer dereference */
		attach_nut("R", t, n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x44, %edx
callq 0x27890
movq -0x8(%rbp), %rdi
callq 0x26070
cmpl $0x0, %eax
je 0x27886
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x44, %edx
callq 0x28010
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1c31d(%rip), %rdi     # 0x43b9e
callq 0x26f00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: mark_defuse
static void
mark_defuse(symentry_t *t, treenode *n, int stc)
{	SymRef *r;

	for (r = curgraph->def_use; r; r = r->nxt)
		if (r->sm == t)
		{	r->status |= stc;
			if (n && (stc & DEREF))
				r->n = n;
			return;
		}

	r = uno_getref(t);
	r->n = n;
	r->status = stc;
	r->nxt = curgraph->def_use;
	curgraph->def_use = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x5e6fe(%rip), %rax     # 0x85fa8
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27903
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x278f3
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x278f1
movl -0x14(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x278f1
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x27948
jmp 0x278f5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x278b2
movq -0x8(%rbp), %rdi
callq 0x20420
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 0x5e67b(%rip), %rax     # 0x85fa8
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq 0x5e664(%rip), %rax     # 0x85fa8
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: has_symbol
static int
has_symbol(symentry_t *s, treenode *n)
{
	if (!n) return 0;

	if (n->syment == s)
		return 1;

	if (n->hdr.which == LEAF_T)
		return 0;

	return has_symbol(s, n->lnode) || has_symbol(s, n->rnode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27c30
movl $0x0, -0x4(%rbp)
jmp 0x27c9b
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x27c47
movl $0x1, -0x4(%rbp)
jmp 0x27c9b
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x27c59
movl $0x0, -0x4(%rbp)
jmp 0x27c9b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x27c10
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x27c90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x27c10
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -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_lts.c
// Function: simple_form
static int
simple_form(symentry_t *s, PathCond *np)	/* can we deduce that s is nonzero from np */
{	treenode *ex = np->exp;

	if (!((leafnode *)np->val)->data.sval) return 0;

	if (debug) printf("\t\tsimpleform: %s\n", ((leafnode *)np->val)->data.sval->str);

	if (strcmp(((leafnode *)np->val)->data.sval->str, "_true_") == 0)
		return simple_nonzero(s, ex);

	if (strcmp(((leafnode *)np->val)->data.sval->str, "_false_") == 0)
		return simple_zero(s, ex);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x40(%rax)
jne 0x27ce6
movl $0x0, -0x4(%rbp)
jmp 0x27d7a
cmpl $0x0, 0x5e2e3(%rip)     # 0x85fd0
je 0x27d0d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1db75(%rip), %rdi     # 0x4587b
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x1d382(%rip), %rsi     # 0x450a6
callq 0x3160
cmpl $0x0, %eax
jne 0x27d40
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27950
movl %eax, -0x4(%rbp)
jmp 0x27d7a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x1d347(%rip), %rsi     # 0x4509e
callq 0x3160
cmpl $0x0, %eax
jne 0x27d73
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27d90
movl %eax, -0x4(%rbp)
jmp 0x27d7a
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_lts.c
// Function: make_suspect
static void
make_suspect(symentry_t *t, treenode *n, int tags)
{	SymExt *v;

	if (localonly) return;

	for (v = curgraph->suspect; v; v = v->nxt)
		if (v->sm == t
		&&  v->n == n)
		{	v->status |= tags;
			break;
		}
	if (!v)
	{	v = uno_getext(t);
		v->n = n;
		v->status = tags;
		v->nxt = curgraph->suspect;
		curgraph->suspect = v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x26372(%rip), %rax     # 0x4e39c
cmpl $0x0, (%rax)
je 0x28034
jmp 0x280d0
movq 0x5df6d(%rip), %rax     # 0x85fa8
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x28084
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x28074
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x28074
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x28084
jmp 0x28076
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x28043
cmpq $0x0, -0x20(%rbp)
jne 0x280d0
movq -0x8(%rbp), %rdi
callq 0x20520
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 0x5def3(%rip), %rax     # 0x85fa8
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq 0x5dedc(%rip), %rax     # 0x85fa8
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_locs
static void
add_locs(symentry_t *t, treenode *n)
{	SymRef *r;

	for (r = curgraph->locs; r; r = r->nxt)
		if (r->sm == t)
			return;

	r = uno_getref(t);
	r->n = n;
	r->nxt = curgraph->locs;
	curgraph->locs = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5deb1(%rip), %rax     # 0x85fa8
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28125
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x28115
jmp 0x28160
jmp 0x28117
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x280ff
movq -0x8(%rbp), %rdi
callq 0x20420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x5de63(%rip), %rax     # 0x85fa8
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq 0x5de4c(%rip), %rax     # 0x85fa8
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_stack
static void
add_stack(symentry_t *t, treenode *n)	/* locals only */
{	SymRef *r;

	uno_assert((dfstack != NULL), "no dfstack - add_stack");

	r = uno_getref(t);
	r->n = n;
	r->nxt = dfstack->symrefs;
	dfstack->symrefs = r;

	if (debug) printf("ADD_STACK %s\n", t->nme->str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x5dcf8(%rip)     # 0x86090
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1d5e8(%rip), %rsi     # 0x4598f
callq 0x1fde0
movq -0x8(%rbp), %rdi
callq 0x20420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x5dcc4(%rip), %rax     # 0x86090
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq 0x5dcae(%rip), %rax     # 0x86090
movq %rcx, (%rax)
cmpl $0x0, 0x5dbe4(%rip)     # 0x85fd0
je 0x28408
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1d5a5(%rip), %rdi     # 0x459a6
movb $0x0, %al
callq 0x30f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: del_stack
static void
del_stack(symentry_t *t, int w)	/* locals only */
{	SymRef *r, *or = (SymRef *) 0;

	if (dfstack)
	for (r = dfstack->symrefs; r; or = r, r = r->nxt)
		if (r->sm == t)
		{	if (!or)
				dfstack->symrefs = r->nxt;
			else
				or->nxt = r->nxt;

			r->nxt = dfs_free;
			dfs_free = r;

			if (debug) printf("DEL_STACK %s [%d]\n", t->nme->str, w);

			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, 0x5dc61(%rip)     # 0x86090
je 0x284e5
movq 0x5dc54(%rip), %rax     # 0x86090
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x284e3
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x284c8
cmpq $0x0, -0x20(%rbp)
jne 0x28476
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x5dc1f(%rip), %rax     # 0x86090
movq %rcx, (%rax)
jmp 0x28486
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x5db23(%rip), %rcx     # 0x85fb0
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x5db10(%rip)     # 0x85fb0
cmpl $0x0, 0x5db29(%rip)     # 0x85fd0
je 0x284c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %edx
leaq 0x1d4f5(%rip), %rdi     # 0x459b4
movb $0x0, %al
callq 0x30f0
jmp 0x284e3
jmp 0x284ca
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28443
jmp 0x284e5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: is_local
static int
is_local(symentry_t *t)
{	SymRef *r;

	for (r = curgraph->locs; r; r = r->nxt)
		if (r->sm == t)
			return r->status;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x5daa9(%rip), %rax     # 0x85fa8
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28537
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x28527
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2853e
jmp 0x28529
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28507
movl $0x0, -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_lts.c
// Function: has_fctcalls
static int
has_fctcalls(DefUse *d)
{	SymList *s;

	if (d)
	for (s = d->other; s; s = s->nxt)
		if (s->mark & FCALL)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2859c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2859a
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2858a
movl $0x1, -0x4(%rbp)
jmp 0x285a3
jmp 0x2858c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2856b
jmp 0x2859c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: find_graph
static Graphs *
find_graph(char *s)
{	Graphs *g;

	for (g = graph; g; g = g->nxt)
	{	if (g == glob_decls)
			continue;
		if (strcmp(s, g->fctnm) == 0)
			return g;
	}

	if (0) printf("uno: no graph %s\n", s);
	return (Graphs *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x5da05(%rip), %rax     # 0x85fc8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2860c
movq -0x18(%rbp), %rax
cmpq 0x5da07(%rip), %rax     # 0x85fe0
jne 0x285dd
jmp 0x285fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x285fc
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28614
jmp 0x285fe
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x285c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: not_fcall
static int
not_fcall(symentry_t *t)
{	SymExt *r;

	for (r = curgraph->fcalls; r; r = r->nxt)
		if (r->sm == t)
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x5d419(%rip), %rax     # 0x85fa8
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28bc4
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x28bb4
movl $0x0, -0x4(%rbp)
jmp 0x28bcb
jmp 0x28bb6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28b97
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_report1
static void
uno_report1(FILE *fd, char *s, int t, SymExt *d)
{	SymExt *r;

	for (r = d; r; r = r->nxt)
	{	if (t == -1
		||  t == r->status)
		fprintf(fd, "%s\t%s\t%s\t%d\n",
			s, r->sm->nme->str,
			r->n->hdr.fnm,
			r->n->hdr.line);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28c55
cmpl $-0x1, -0x14(%rbp)
je 0x28c08
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x28c45
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %r9d
leaq 0xc178(%rip), %rsi      # 0x34db6
movb $0x0, %al
callq 0x3170
jmp 0x28c47
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x28bef
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_complain
static void
uno_complain(SymRef *r, char *qualify, char *issue)
{
	if (strcmp(qualify, "extern ") == 0)	/* unused extern */
	{	char *p = strstr(r->n->hdr.fnm, ".h");
		if (p && strcmp(p, ".h") == 0)	/* in header file */
			return;			/* too fussy */
	}

	fprintf(stdout, "uno: ");
	if (r->n) fprintf(stdout, "%s:%d:", r->n->hdr.fnm, r->n->hdr.line);
	fprintf(stdout, "\t%sglobal variable '%s' %s\n",
		qualify, r->sm->nme->str, issue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc459(%rip), %rsi      # 0x350d8
callq 0x3160
cmpl $0x0, %eax
jne 0x28cc8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x1cfb3(%rip), %rsi     # 0x45c4f
callq 0x3240
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x28cc6
movq -0x20(%rbp), %rdi
leaq 0x1cf98(%rip), %rsi     # 0x45c4f
callq 0x3160
cmpl $0x0, %eax
jne 0x28cc6
jmp 0x28d49
jmp 0x28cc8
movq 0x25301(%rip), %rax     # 0x4dfd0
movq (%rax), %rdi
leaq 0x1c2b9(%rip), %rsi     # 0x44f92
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28d1a
movq 0x252de(%rip), %rax     # 0x4dfd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
leaq 0x1cf7f(%rip), %rsi     # 0x45c92
movb $0x0, %al
callq 0x3170
movq 0x252af(%rip), %rax     # 0x4dfd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0x1cf10(%rip), %rsi     # 0x45c52
movb $0x0, %al
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_setup
static void
nut_setup(Graphs *g)	/* build abstracted graph */
{	State *s;
	Trans *t;

	for (s = g->all; s; s = s->all)
	for (t = s->succ; t; t = t->nxt)
		if (t->knz)
			nut_insertion(g, s, t);

	for (s = g->all; s; s = s->all)
		nuts_forward(g, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28fbe
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28fae
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28f9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29140
jmp 0x28fa0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28f7b
jmp 0x28fb0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28f68
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28fec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29210
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28fca
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_hunt
static void
nut_hunt(FILE *fd, State *s)
{	Trans *t;
	Nuts *q;

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

	if (s->visited)
	{	fprintf(fd, "{%lu}\n", s->uno_state);
		return;
	}
	s->visited = 1;
	s->uno_state = Cnt++;

	fprintf(fd, ">%lu>\n", s->uno_state);

	if (!s->n->hdr.nuts)
		fprintf(fd, "[]\n");
	for (q = s->n->hdr.nuts; q; q = q->nxt)
		fprintf(fd, "[%s]\n", q->nut);

	for (t = s->direct; t; t = t->nxt)
	{	nut_hunt(fd, t->branch);
		fprintf(fd, "<%lu<\n", s->uno_state);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29021
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29026
jmp 0x2913a
movq -0x10(%rbp), %rax
cmpw $0x0, 0x4a(%rax)
je 0x29050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x1ccb6(%rip), %rsi     # 0x45cfa
movb $0x0, %al
callq 0x3170
jmp 0x2913a
movq -0x10(%rbp), %rax
movw $0x1, 0x4a(%rax)
movq 0x2516f(%rip), %rcx     # 0x4e1d0
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x25161(%rip)     # 0x4e1d0
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x1cc77(%rip), %rsi     # 0x45d01
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x290b1
movq -0x8(%rbp), %rdi
leaq 0x1cc69(%rip), %rsi     # 0x45d13
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x290ee
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x1cc3e(%rip), %rsi     # 0x45d17
movb $0x0, %al
callq 0x3170
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x290c0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2913a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x29000
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x1cbce(%rip), %rsi     # 0x45cf3
movb $0x0, %al
callq 0x3170
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x290fa
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_insertion
static void
nut_insertion(Graphs *g, State *s, Trans *t)
{	State  *ns;
	Trans  *nt;
	SymRef *r = t->knz;

	if (debug) dumknow(s->n, t);
	 /*
	  * insert dummy state between s and t->branch,
	  * to attach nut knz info
	  */
	nt = get_trans();
	nt->branch = t->branch;

	ns = create_state(g);	/* inserted new state */
	ns->n = clone_node(s->n);	/* points to the same node */
	ns->succ = nt;		/* goes to the original successor */
	t->branch = ns;		/* the old transition now points to inserted state */

	for (r = t->knz; r; r = r->nxt)
		attach_nut("N", r->sm, ns->n);	/* non-zero vars */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x5ce69(%rip)     # 0x85fd0
je 0x29179
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x25390
callq 0x23020
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x22500
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x29280
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29208
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x1abb3(%rip), %rdi     # 0x43da8
callq 0x26f00
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x291d9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nuts_forward
static void
nuts_forward(Graphs *g, State *s)
{	Trans *t;

	if (!s->direct)
	for (t = s->succ; t; t = t->nxt)
	{	cfg_unvisit(g->all);
		s->visited = 1;
		nut_prepare(s, t->branch);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x29276
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29274
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq -0x10(%rbp), %rax
movw $0x1, 0x4a(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x292d0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29237
jmp 0x29276
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: clone_node
static treenode *
clone_node(treenode *r)
{	treenode *n;
	n = (treenode *) emalloc(sizeof(treenode));
	memcpy(n, r, sizeof(treenode));
	n->hdr.nuts = (Nuts *) 0;
	n->hdr.defuse = (DefUse *) 0;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x50, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x3190
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_prepare
static void
nut_prepare(State *from, State *to)	/* insert forward arcs to nodes with a nut attached */
{	Trans *t;

	if (!to || !to->n || to->visited)
		return;
	to->visited = 1;

	if (to->n->hdr.nuts
	|| !(to->succ && to->succ->branch))
	{	for (t = from->direct; t; t = t->nxt)
			if (t->branch == to)
				break;
		if (!t)
		{	t = get_trans();
			t->branch = to;
			t->nxt = from->direct;
			from->direct = t;
		}
		return;
	}

	for (t = to->succ; t; t = t->nxt)
		nut_prepare(from, t->branch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x292fe
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x292fe
movq -0x10(%rbp), %rax
movswl 0x4a(%rax), %eax
cmpl $0x0, %eax
je 0x29303
jmp 0x293d4
movq -0x10(%rbp), %rax
movw $0x1, 0x4a(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x29335
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x29335
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x293a2
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29368
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x29358
jmp 0x29368
jmp 0x2935a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29341
cmpq $0x0, -0x18(%rbp)
jne 0x293a0
callq 0x23020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x293d4
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x293d4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x292d0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x293ae
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/explore.c
// Function: exclude_location
int
exclude_location(treenode *n)
{
	if (!xrepro || !n || !n->hdr.fnm) return 1;

	if (Verbose) return 0;

	return (strncmp(W_FILE, "./_", 3) == 0
	     || strncmp(W_FILE, "/usr/include", strlen("/usr/include")) == 0
	     || strncmp(W_FILE, "/usr/lib", strlen("/usr/lib")) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x23a89(%rip), %rax     # 0x4e38c
cmpl $0x0, (%rax)
je 0x2a91a
cmpq $0x0, -0x10(%rbp)
je 0x2a91a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a926
movl $0x1, -0x4(%rbp)
jmp 0x2aa19
leaq 0x23a4b(%rip), %rax     # 0x4e378
cmpl $0x0, (%rax)
je 0x2a93e
movl $0x0, -0x4(%rbp)
jmp 0x2aa19
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a957
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a962
movq 0x5b772(%rip), %rax     # 0x860d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1b4d7(%rip), %rsi     # 0x45e44
movl $0x3, %edx
callq 0x3070
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2aa0e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a9a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2a9ab
movq 0x5b729(%rip), %rax     # 0x860d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1a5ab(%rip), %rsi     # 0x44f61
movl $0xc, %edx
callq 0x3070
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2aa0e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a9e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2a9f0
movq 0x5b6e4(%rip), %rax     # 0x860d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1b44d(%rip), %rsi     # 0x45e48
movl $0x8, %edx
callq 0x3070
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -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/explore.c
// Function: follow_chain
int
follow_chain(treenode *n)
{
	if (IF_THEN_ELSE(n))
	{	return follow_chain(IF_ELSE(n)->rnode);
	} else if (IF_THEN(n))
	{	return 1;	/* last leg is not an else */
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x2aa67
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2aa67
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x48(%rax), %rdi
callq 0x2aa30
movl %eax, -0x4(%rbp)
jmp 0x2aa83
movq -0x10(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x2aa7a
movl $0x1, -0x4(%rbp)
jmp 0x2aa83
jmp 0x2aa7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/explore.c
// Function: has_default
int
has_default(treenode *n)
{
	if (!n
	||  SWITCH(n)
	||  B_TYPE(n) == LEAF_T)
	{	return 0;
	}

        if (B_TYPE(n) == NODE_T
	&&  W_TYPE(n) == TN_LABEL
	&&  B_TYPE(n->lnode) == LEAF_T)
	{	return (n->lnode->hdr.tok == DEFLT);
	}

	return has_default(n->rnode) || has_default(n->lnode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ab26
movq -0x10(%rbp), %rax
cmpl $0x21, 0x1c(%rax)
je 0x2ab26
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2ab2f
movl $0x0, -0x4(%rbp)
jmp 0x2aba5
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x2ab6b
movq -0x10(%rbp), %rax
cmpl $0x22, 0x1c(%rax)
jne 0x2ab6b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x1, (%rax)
jne 0x2ab6b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x113, 0x18(%rax)      # imm = 0x113
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2aba5
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2ab00
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x2ab9a
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2ab00
cmpl $0x0, %eax
setne %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
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/explore.c
// Function: has_extern
int
has_extern(treenode *n)
{
	assert(W_TYPE(n) == TN_TYPE_LIST);
	assert(n->lnode != NULL);
	
	return (B_TYPE(n->lnode) == LEAF_T
	     && W_TYPE(n->lnode) == TN_TYPE
	     && n->lnode->hdr.tok == EXTRN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x14, 0x1c(%rax)
jne 0x2abc8
jmp 0x2abe7
leaq 0x1b282(%rip), %rdi     # 0x45e51
leaq 0x1b295(%rip), %rsi     # 0x45e6b
movl $0x297, %edx            # imm = 0x297
leaq 0x1b293(%rip), %rcx     # 0x45e75
callq 0x3120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2abf4
jmp 0x2ac13
leaq 0x1b295(%rip), %rdi     # 0x45e90
leaq 0x1b269(%rip), %rsi     # 0x45e6b
movl $0x298, %edx            # imm = 0x298
leaq 0x1b267(%rip), %rcx     # 0x45e75
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x9(%rbp)
jne 0x2ac4d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
xorl %eax, %eax
cmpl $0x2e, 0x1c(%rcx)
movb %al, -0x9(%rbp)
jne 0x2ac4d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x118, 0x18(%rax)      # imm = 0x118
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/explore.c
// Function: has_non_obj
int
has_non_obj(treenode *n)
{	/* at least one child node is different from TN_OBJ_DEF */

	assert(W_TYPE(n) == TN_TYPE_LIST);

	if (n->lnode)
	{	if (W_TYPE(n->lnode) != TN_OBJ_DEF)
			return 1;
		if (W_TYPE(n->lnode) == TN_TYPE_LIST)
			return has_non_obj(n->lnode);
	}

	if (n->rnode)
	{	if (W_TYPE(n->rnode) != TN_OBJ_DEF)
			return 1;
		if (W_TYPE(n->rnode) == TN_TYPE_LIST)
			return has_non_obj(n->rnode);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x14, 0x1c(%rax)
jne 0x2ac78
jmp 0x2ac97
leaq 0x1b1d2(%rip), %rdi     # 0x45e51
leaq 0x1b1e5(%rip), %rsi     # 0x45e6b
movl $0x2a3, %edx            # imm = 0x2A3
leaq 0x1b20f(%rip), %rcx     # 0x45ea1
callq 0x3120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2acdb
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x18, 0x1c(%rax)
je 0x2acb9
movl $0x1, -0x4(%rbp)
jmp 0x2ad26
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x14, 0x1c(%rax)
jne 0x2acd9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2ac60
movl %eax, -0x4(%rbp)
jmp 0x2ad26
jmp 0x2acdb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2ad1f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x18, 0x1c(%rax)
je 0x2acfd
movl $0x1, -0x4(%rbp)
jmp 0x2ad26
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x14, 0x1c(%rax)
jne 0x2ad1d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2ac60
movl %eax, -0x4(%rbp)
jmp 0x2ad26
jmp 0x2ad1f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop