LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: killpath
static int
killpath(treenode *z)
{	int hasval = 0, thisval = 0;

	if (z->hdr.type == TN_EXPR
	&&  z->hdr.tok  == COMMA)	/* foo(),goo() */
		return killpath(z->rnode) || killpath(z->lnode);

	if (z->hdr.type == TN_FUNC_CALL
	&&  z->lnode->hdr.type == TN_IDENT) /* function call */
	{
		/* check if the first argument is an int */
		if (z->rnode)
		{	treenode *t = z->rnode;

			while (t && t->hdr.type == TN_EXPR_LIST)
				t = t->lnode; /* leftmost */
		 	if (t
		 	&& t->hdr.which == LEAF_T
		 	&& t->hdr.type == TN_INT)
			{	hasval = 1;
				thisval = ((leafnode *)t)->data.ival;
		}	}

		return (no_return(((leafnode *)z->lnode)->data.sval->str, hasval, thisval));
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl 0x1c(%rbx), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
jne 0x14f24
cmpl $0x140, 0x18(%rbx)      # imm = 0x140
jne 0x14fb2
movq 0x48(%rbx), %rdi
callq 0x14ee8
testl %eax, %eax
jne 0x14fac
movq 0x40(%rbx), %rbx
jmp 0x14ef6
cmpl $0x3, %ecx
jne 0x14fb2
movq 0x40(%rbx), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x14fb2
movq 0x48(%rbx), %rax
xorl %r14d, %r14d
movb $0x1, %r15b
testq %rax, %rax
je 0x14f6a
testq %rax, %rax
je 0x14f6a
movl 0x1c(%rax), %edx
cmpl $0xa, %edx
jne 0x14f59
movq 0x40(%rax), %rax
jmp 0x14f46
cmpl $0x30, %edx
jne 0x14f6a
cmpl $0x1, (%rax)
jne 0x14f6a
movl 0x40(%rax), %r14d
xorl %r15d, %r15d
movq 0x40(%rcx), %rax
movq 0x8(%rax), %rbx
leaq 0x59eef(%rip), %r12     # 0x6ee68
movq (%r12), %r12
testq %r12, %r12
je 0x14fb0
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x3190
testl %eax, %eax
jne 0x14fa6
cmpl $0x0, 0x8(%r12)
je 0x14fac
testb %r15b, %r15b
jne 0x14fa6
cmpl %r14d, 0xc(%r12)
je 0x14fac
addq $0x10, %r12
jmp 0x14f79
movl %ebp, %eax
jmp 0x14fb2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_redirect
static State *
lts_redirect(State *s)
{	State *stc = s;
	leafnode *ln;
	SwStack *frame;

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

	for (frame = stck; frame; frame = frame->nxt)
		if (frame->s == s)
		{	fprintf(stderr, "uno: %s:%d: goto cycle\n",
				s->n->hdr.fnm,
				s->n->hdr.line);
			return s;
		}

	frame = (SwStack *) emalloc(sizeof(SwStack));
	frame->s = s;
	frame->nxt = stck;
	stck = frame;
	
	if (s->n->hdr.which == NODE_T)
	{	switch (s->n->hdr.type) {
		case TN_JUMP:
			if (s->n->hdr.tok == RETURN)
				break;
			if ((ln = (leafnode *) s->n->lnode) != NULL)	/* assign */
			{	stc = lts_label_find(ln->data.sval->str);
				if (!stc) stc = s;
			}
			break;

		case TN_BLOCK:
		case TN_STEMNT:
		case TN_LABEL:	/* skip fillers, if unique successor */
			if (!s->succ)	/* not yet set, but already known to be unique */
				stc = s->nxt;
			else if (!s->succ->nxt)
				stc = s->succ->branch;

			if (!stc) stc = s;
			break;
		default:
			break;
	}	}

	if (stc != s)
		stc = lts_redirect(stc);

	stck = stck->nxt;	/* pop frame stack */

	return stc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15010
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x15108
leaq 0x59ea5(%rip), %rcx     # 0x6ee80
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x15017
leaq 0x8(%rdx), %rcx
cmpq %rbx, (%rdx)
jne 0x14fdb
movq 0x22005(%rip), %rcx     # 0x36ff8
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
leaq 0x18fb3(%rip), %rsi     # 0x2dfb7
xorl %eax, %eax
callq 0x31a0
jmp 0x15108
xorl %ebx, %ebx
jmp 0x15108
pushq $0x10
popq %rdi
callq 0x4da5
movq %rbx, (%rax)
movq 0x59e57(%rip), %rcx     # 0x6ee80
movq %rcx, 0x8(%rax)
movq %rax, 0x59e4c(%rip)     # 0x6ee80
movq (%rbx), %rax
cmpl $0x4, (%rax)
jne 0x150f6
movl 0x1c(%rax), %ecx
leal -0x22(%rcx), %edx
cmpl $0x2, %edx
jb 0x150ba
cmpl $0x4, %ecx
je 0x150ba
cmpl $0x1d, %ecx
jne 0x150f6
cmpl $0x120, 0x18(%rax)      # imm = 0x120
je 0x150f6
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x150f6
movq 0x40(%rax), %rax
movq 0x8(%rax), %r14
xorl %edi, %edi
testq %r14, %r14
setne %dil
leaq 0x18f44(%rip), %rsi     # 0x2dfcf
callq 0x1225f
leaq 0x59e09(%rip), %rax     # 0x6eea0
movq 0x59dba(%rip), %rcx     # 0x6ee58
movq (%rax), %rax
testq %rax, %rax
je 0x15117
cmpq %r14, (%rax)
jne 0x150b4
movq 0x8(%rax), %rdx
cmpq (%rcx), %rdx
je 0x15111
addq $0x18, %rax
jmp 0x1509e
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x150d3
cmpq $0x0, 0x18(%rax)
movq %rbx, %r15
jne 0x150da
addq $0x10, %rax
jmp 0x150d7
leaq 0x60(%rbx), %rax
movq (%rax), %r15
testq %r15, %r15
cmoveq %rbx, %r15
cmpq %rbx, %r15
je 0x150f3
movq %r15, %rdi
callq 0x14fbb
movq %rax, %rbx
jmp 0x150f6
movq %r15, %rbx
movq 0x59d83(%rip), %rax     # 0x6ee80
movq 0x8(%rax), %rax
movq %rax, 0x59d78(%rip)     # 0x6ee80
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%rax), %r15
jmp 0x150da
movq 0x21eda(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x18ec2(%rip), %rsi     # 0x2dfea
xorl %r15d, %r15d
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x150da
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: cfg_unvisit
static void
cfg_unvisit(State *t)
{	State *s;

	for (s = t; s; s = s->all)
	{	s->visited = 0;
		s->snapshot = rev_release(s->snapshot);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x15159
andw $0x0, 0x4a(%rbx)
movq 0x8(%rbx), %rdi
callq 0x125c7
andq $0x0, 0x8(%rbx)
movq 0x68(%rbx), %rbx
jmp 0x1513b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: gen_lts
static void
gen_lts(State *s)
{	State *n;
	Trans *t;
	ArBound *b;
	char *z, *zz;
	int cnt;

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

	s->visited = 1;

	for (z = zz = x_stmnt(s->n), cnt=0; *zz; zz++) {
		if (*zz == '"') *zz = '\'';
		if (*zz == '\n') *zz = ' ';
		if (*zz == '\r') *zz = ' ';
		if (++cnt > 16) { *zz = '\0'; break; }
	}
#if 1
	printf("N%p [label=\"%d : %s : %s : ",
		s->n,
		s->n->hdr.line,
		name_of_node(s->n->hdr.type),
		z );
#else
	printf("N%p [label=\"%s : %d : %s <%d> : %s : ",
		s->n,
		s->n->hdr.fnm,
		s->n->hdr.line,
		name_of_node(s->n->hdr.type),
		s->iscond,
		x_stmnt(s->n) );
#endif

	if (s->n->hdr.type == TN_IF)
		dump_defuse(((if_node *)s->n)->cond->hdr.defuse, stdout);
	else
		dump_defuse(s->n->hdr.defuse, stdout);

	for (b = s->pvb; b; b = b->nxt)
	{	explain_bound("", b, (treenode *)0);
		printf(",");
	}

	printf("\"];\n");

	for (t = s->succ; t && t->branch; t = t->nxt)
	{	n = t->branch;
		printf("N%p -> N%p;\n", s->n, n->n);
		gen_lts(n);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x15182
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1517a
cmpw $0x0, 0x4a(%rbx)
je 0x15183
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, 0x4a(%rbx)
callq 0x4ac7
movq %rax, %r14
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
cmpl $0xa, %ecx
je 0x151af
cmpl $0xd, %ecx
je 0x151af
movb $0x27, %dl
cmpl $0x22, %ecx
je 0x151b1
testl %ecx, %ecx
jne 0x151b5
jmp 0x151c4
movb $0x20, %dl
movb %dl, (%r14,%rax)
cmpl $0x10, %eax
je 0x151bf
incq %rax
jmp 0x15193
movb $0x0, (%r14,%rax)
movq (%rbx), %r15
movl 0x10(%r15), %ebp
movl 0x1c(%r15), %edi
callq 0x66b2
leaq 0x18e4c(%rip), %rdi     # 0x2e027
movq %r15, %rsi
movl %ebp, %edx
movq %rax, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x3100
movq (%rbx), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x151fa
movq 0x40(%rax), %rax
movq 0x28(%rax), %rdi
movq 0x21dcb(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
callq 0xedd4
leaq 0x38(%rbx), %r14
leaq 0x8b83(%rip), %r15      # 0x1dd9b
pushq $0x2c
popq %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x1523d
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x18788
movl %ebp, %edi
callq 0x3040
addq $0x28, %r14
jmp 0x1521b
leaq 0x19281(%rip), %rdi     # 0x2e4c5
callq 0x30a0
leaq 0x50(%rbx), %r12
leaq 0x18def(%rip), %r14     # 0x2e043
movq (%r12), %r12
testq %r12, %r12
je 0x1517a
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x1517a
movq (%rbx), %rsi
movq (%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x3100
movq %r15, %rdi
callq 0x1515b
addq $0x18, %r12
jmp 0x15254
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: cyclo_dfs
static void
cyclo_dfs(State *s)
{	State *n = (State *) 0, *lastn;
	Trans *t;

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

	s->visited = 1;

	cnodes++;
	for (t = s->succ; t && t->branch; t = t->nxt)
	{	lastn = n;
		n = t->branch;
		cedges++;

		if (s->iscond && n == lastn)
			cedges--;
		/* case X: case Y: case Z: ...; break; */

		if (s->n->hdr.type == TN_JUMP)
			cedges++;
		cyclo_dfs(n);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x152ac
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x152a7
cmpw $0x0, 0x4a(%rbx)
je 0x152ad
popq %rbx
popq %r14
popq %r15
retq
movw $0x1, 0x4a(%rbx)
incl 0x59c6b(%rip)           # 0x6ef24
leaq 0x50(%rbx), %r15
xorl %eax, %eax
movq (%r15), %r15
testq %r15, %r15
je 0x152a7
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x152a7
cmpw $0x0, 0x48(%rbx)
sete %cl
cmpq %rax, %r14
setne %al
orb %cl, %al
movzbl %al, %eax
addl 0x59c37(%rip), %eax     # 0x6ef20
movl %eax, 0x59c31(%rip)     # 0x6ef20
movq (%rbx), %rcx
cmpl $0x1d, 0x1c(%rcx)
jne 0x15300
incl %eax
movl %eax, 0x59c20(%rip)     # 0x6ef20
movq %r14, %rdi
callq 0x1528d
addq $0x18, %r15
movq %r14, %rax
jmp 0x152bf
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_report0
static void
uno_report0(FILE *fd, char *s, int t, SymRef *d)
{	SymRef *r;

	for (r = d; r; r = r->nxt)
		if (t == -1
		||  r->status == t)
		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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x83c7(%rip), %r12      # 0x1dd9c
testq %rbx, %rbx
je 0x15a0c
cmpl %ebp, 0x10(%rbx)
jne 0x15a06
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rdx), %r8
movl 0x10(%rdx), %r9d
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
movq 0x18(%rbx), %rbx
jmp 0x159d5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15a96
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12673
movq %rax, %rbx
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x15a60
movq %rax, 0x18(%rbx)
jmp 0x15a98
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x15adf
movq (%r14), %rdi
callq 0x15aea
testl %eax, %eax
jne 0x15ac3
movq 0x10(%r14), %r14
jmp 0x15aac
callq 0x15a15
movq %rax, %rbx
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rdi
callq 0x15aa3
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r15
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x15b3b
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x15b20
movq %r14, %rdi
callq 0x15b48
testl %eax, %eax
jne 0x15b38
movq %r14, %rdi
callq 0x15b72
testl %eax, %eax
jne 0x15b38
cmpl $0x1, (%rbx)
je 0x15b3b
movq 0x40(%rbx), %rdi
callq 0x15aea
testl %eax, %eax
jne 0x15b38
movq 0x48(%rbx), %rbx
jmp 0x15afa
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x59341(%rip), %rcx     # 0x6ee90
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x15b62
cmpq %rdi, (%rcx)
je 0x15b65
addq $0x18, %rcx
jmp 0x15b4f
xorl %eax, %eax
retq
xorl %eax, %eax
testl $0xfffffffd, 0x10(%rcx) # imm = 0xFFFFFFFD
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_fcall
static void
add_fcall(symentry_t *t, treenode *n, int status)
{	SymExt *r;

	if (debug)
		printf("fct %s calls fct %s status %d\n",
		curgraph->fctnm, t->nme->str, status);

	for (r = curgraph->fcalls; r; r = r->nxt)
		if (r->sm == t)
		{	if (status & DEF)
				r->n = n;	/* remember failures to use ret value */
			break;
		}
	if (!r)
	{	r = uno_getext(t);
		r->n = n;
		r->nxt = curgraph->fcalls;
		curgraph->fcalls = r;
	}

	r->status |= status;

	switch (r->status) {
	case DEF:		attach_nut("C", t, n); break;
	case USE:		attach_nut("c", t, n); break;
	case DEF|USE:		attach_nut("b", t, n); break;
	case DEF|HIDE:		attach_nut("h", t, n); break;
	case USE|HIDE:		attach_nut("i", t, n); break;
	case DEF|USE|HIDE:	attach_nut("j", t, n); break;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58d4c(%rip), %rax     # 0x6ee58
addq $0x28, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x16123
cmpq %r14, (%rax)
je 0x16144
addq $0x18, %rax
jmp 0x16110
movq %r14, %rdi
callq 0x126c5
movq %rbx, 0x8(%rax)
movq 0x58d22(%rip), %rcx     # 0x6ee58
movq 0x28(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x28(%rcx)
jmp 0x1614e
testb $0x1, %bpl
je 0x1614e
movq %rbx, 0x8(%rax)
orl 0x10(%rax), %ebp
movl %ebp, 0x10(%rax)
cmpl $0x1, %ebp
je 0x161ad
cmpl $0x205, %ebp            # imm = 0x205
je 0x161a4
cmpl $0x5, %ebp
je 0x16184
cmpl $0x201, %ebp            # imm = 0x201
je 0x16196
cmpl $0x204, %ebp            # imm = 0x204
je 0x1618d
cmpl $0x4, %ebp
jne 0x1619f
leaq 0x7b3c(%rip), %rdi      # 0x1dcbe
jmp 0x161b4
leaq 0x18d6e(%rip), %rdi     # 0x2eef9
jmp 0x161b4
leaq 0x17fb8(%rip), %rdi     # 0x2e14c
jmp 0x161b4
leaq 0x1823e(%rip), %rdi     # 0x2e3db
jmp 0x161b4
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17fa3(%rip), %rdi     # 0x2e14e
jmp 0x161b4
leaq 0x1693e(%rip), %rdi     # 0x2caf2
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x164bf
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: attach_nut
static void
attach_nut(char *pref, symentry_t *t, treenode *n)
{	char nr[16];
	char *newnut;
	Nuts *q;

	if (!t || !n) return;

	sprintf(nr, "%d", n->hdr.line);
	if (!n->hdr.fnm) n->hdr.fnm = "--";
	newnut = (char *) emalloc(
			  strlen(pref)
			+ strlen("\t\t\t")
			+ strlen(t->nme->str)
			+ strlen(n->hdr.fnm?n->hdr.fnm:"")
			+ strlen(nr)
			+ 1);
	sprintf(newnut, "%s\t%s\t%s\t%s", pref, t->nme->str, n->hdr.fnm?n->hdr.fnm:"", nr);

	for (q = n->hdr.nuts; q; q = q->nxt)
		if (strcmp(q->nut, newnut) == 0)
			break;	/* already there */
	if (!q)
	{	q = (Nuts *) emalloc(sizeof(Nuts));
		q->nut = newnut;
		q->nxt = n->hdr.nuts;
		n->hdr.nuts = q;
		curgraph->hasnuts = 1;
	}
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x165db
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%rdx), %edx
leaq 0x172d7(%rip), %rsi     # 0x2d7cb
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3260
movq 0x8(%rbx), %r12
testq %r12, %r12
jne 0x16512
leaq 0x7cf7(%rip), %r12      # 0x1e205
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x30d0
movq %rax, %rbp
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x30d0
movq %rax, %r13
movq %r12, %rdi
callq 0x30d0
movq %rax, %r12
movq %rsp, %rdi
callq 0x30d0
addq %rbp, %r12
addq %r13, %r12
leaq (%rax,%r12), %rdi
addq $0x4, %rdi
callq 0x4da5
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x782f(%rip), %r8       # 0x1dd9b
cmovneq %rax, %r8
leaq 0x17bd9(%rip), %rsi     # 0x2e150
movq %r12, %rdi
movq %r14, %rdx
movq %rsp, %r9
xorl %eax, %eax
callq 0x3260
addq $0x20, %rbx
movq %rbx, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x165ab
movq (%r14), %rdi
movq %r12, %rsi
callq 0x3190
addq $0x8, %r14
testl %eax, %eax
jne 0x1658e
jmp 0x165cd
pushq $0x10
popq %rdi
callq 0x4da5
movq %r12, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movq 0x58891(%rip), %rax     # 0x6ee58
movw $0x1, 0x44(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4f9e
testl %eax, %eax
jne 0x16632
leaq 0x5889f(%rip), %rax     # 0x6ee98
movq (%rax), %rax
testq %rax, %rax
je 0x1660c
cmpq %r15, (%rax)
je 0x1662f
addq $0x18, %rax
jmp 0x165f9
movq %r15, %rdi
callq 0x12673
movl %ebx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x58876(%rip), %rcx     # 0x6ee98
movq %rcx, 0x18(%rax)
movq %rax, 0x5886b(%rip)     # 0x6ee98
jmp 0x16632
orl %ebx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_gstack
static SymRef *
add_gstack(symentry_t *t, treenode *n, int mark)
{	SymRef *r, *s, *lr;
	int x;

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

/*	if (is_enum_const(t)) return;	*/

	if (debug)
	printf("\tadd_gstack %s [%s:%d] + %d\n",
		t->nme->str, n->hdr.fnm, n->hdr.line, mark);

	if (!dfstack->globrefs)	/* empty list */
	{	r = uno_getref(t);
		r->n = n;
		r->status = mark;
		dfstack->globrefs = r;
		goto done;
	}

	lr = (SymRef *) 0;
	for (r = dfstack->globrefs; r; lr = r, r = r->nxt)	/* keep list sorted */
	{	if (debug) printf("\t<%s> status: [%d]\n", r->sm->nme->str, r->status);
		x = strcmp(r->sm->nme->str, t->nme->str);

		if (x < 0)
			continue;

		if (x == 0)
			r->status |= mark;
		else
		{	s = uno_getref(t);
			s->n = n;
			s->status = mark;
			s->nxt = r;	/* insert before r */
			if (!lr)	/* at head of list */
				dfstack->globrefs = s;
			else
				lr->nxt = s;
			r = s;
		}
		goto done;
	}
	/* fell off the end of the list - item should go at the end */
	r = uno_getref(t);
	r->n = n;
	r->status = mark;
	lr->nxt = r;	/* list had at least 1 item, so lr is set */
done:
	if (!(r->status & DEF))
		return r;

	return (SymRef *) 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
cmpq $0x0, 0x588a8(%rip)     # 0x6ef28
setne %dil
leaq 0x17ad1(%rip), %rsi     # 0x2e15c
callq 0x1225f
movq 0x58891(%rip), %rax     # 0x6ef28
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x166d3
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %r12
xorl %r13d, %r13d
testq %rax, %rax
je 0x166ef
movq %rax, %rbp
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3190
testl %eax, %eax
jns 0x16700
movq 0x18(%rbp), %rax
movq %rbp, %r13
jmp 0x166ab
movq %r15, %rdi
callq 0x12673
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x5883f(%rip), %rcx     # 0x6ef28
movq %rax, 0x8(%rcx)
jmp 0x16723
movq %r15, %rdi
callq 0x12673
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
jmp 0x1671a
je 0x16720
movq %r15, %rdi
callq 0x12673
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq %rbp, 0x18(%rax)
testq %r13, %r13
je 0x166e2
movq %rax, 0x18(%r13)
jmp 0x16723
orl %ebx, 0x10(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x586a0(%rip), %rax     # 0x6ee58
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x167d5
cmpq %rdi, (%rax)
jne 0x167b8
orl %ebp, 0x10(%rax)
testb $0x40, %bpl
je 0x167f4
movq %rbx, 0x8(%rax)
jmp 0x167f4
callq 0x12673
movq %rbx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x58670(%rip), %rcx     # 0x6ee58
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: simple_nonzero
static int
simple_nonzero(symentry_t *s, treenode *ex)
{
	if (!ex) return 0;

	if (debug)
	printf("SNZ %s, %s <%s>\n", s->nme->str, name_of_node(ex->hdr.type), x_stmnt(ex));

	if (ex->hdr.type == TN_IDENT
	&&  ex->syment == s)
	{	if (debug) printf("	s -- pattern matches\n");
		return 1;	/* s */
	}

	if (ex->hdr.type != TN_EXPR)
		return 0;

	if (ex->hdr.tok == AND)
		return simple_nonzero(s, ex->lnode)
		||     simple_nonzero(s, ex->rnode);

	if (ex->hdr.tok == OR)
		return simple_nonzero(s, ex->lnode)
		&&     simple_nonzero(s, ex->rnode);

	if (ex->hdr.tok == NOT
	&&  ex->lnode == ZT
	&&  ex->rnode->hdr.type == TN_EXPR
	&&  ex->rnode->hdr.tok == EQUAL
	&&  ex->rnode->lnode
	&&  ex->rnode->lnode->hdr.type == TN_IDENT
	&&  ex->rnode->lnode->syment == s
	&&  is_zero_val(ex->rnode->rnode))
	{	if (debug) printf("	!(s == 0) -- pattern matches\n");
		return 1;	/* !(s == 0) */
	}

	if (ex->hdr.tok == NOT_EQ
	&&  ex->lnode
	&&  ex->lnode->hdr.type == TN_IDENT
	&&  ex->lnode->syment == s
	&&  is_zero_val(ex->rnode))
	{	if (debug) printf("	(s != 0) -- pattern matches\n");
		return 1;	/* (s != 0) */
	}

	if (debug) printf("	nonoftheabove (%d %p)\n", ex->hdr.tok, ex->lnode);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %r14, %r14
je 0x168ce
movl 0x1c(%r14), %ecx
cmpl $0x28, %ecx
jne 0x16860
movl 0x18(%r14), %eax
cmpl $0x150, %eax            # imm = 0x150
je 0x16843
cmpl $0x151, %eax            # imm = 0x151
jne 0x16870
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x167fb
testl %eax, %eax
je 0x1685a
jmp 0x168cc
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x167fb
movl %eax, %ecx
movl $0x0, %eax
testl %ecx, %ecx
je 0x168ce
movq 0x48(%r14), %r14
jmp 0x16808
cmpl $0x2d, %ecx
jne 0x168ce
xorl %eax, %eax
cmpq %rbx, 0x38(%r14)
sete %al
jmp 0x168ce
cmpl $0x13a, %eax            # imm = 0x13A
je 0x168b3
cmpl $0x162, %eax            # imm = 0x162
jne 0x168c8
cmpq $0x0, 0x40(%r14)
jne 0x168c8
movq 0x48(%r14), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x168c8
cmpl $0x137, 0x18(%rax)      # imm = 0x137
jne 0x168c8
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x168c8
cmpl $0x2d, 0x1c(%rcx)
jne 0x168c8
cmpq %rbx, 0x38(%rcx)
jne 0x168c8
movq 0x48(%rax), %rdi
jmp 0x168d7
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x168c8
cmpl $0x2d, 0x1c(%rax)
jne 0x168c8
cmpq %rbx, 0x38(%rax)
je 0x168d3
xorl %eax, %eax
jmp 0x168ce
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x48(%r14), %rdi
callq 0x12892
movl %eax, %ecx
movl %ebp, %eax
testl %ecx, %ecx
jne 0x168ce
jmp 0x168c8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %rbx, %rbx
je 0x1691d
cmpq %r14, 0x38(%rbx)
je 0x1691b
cmpl $0x1, (%rbx)
je 0x1691d
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x168e6
testl %eax, %eax
jne 0x1691b
movq 0x48(%rbx), %rbx
jmp 0x168f3
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x16964
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rax), %r15
leaq 0x1744c(%rip), %rsi     # 0x2dd91
movq %r15, %rdi
callq 0x3190
testl %eax, %eax
je 0x1696c
leaq 0x17431(%rip), %rsi     # 0x2dd89
movq %r15, %rdi
callq 0x3190
testl %eax, %eax
je 0x1697c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x167fb
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x16989
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: simple_zero
static int
simple_zero(symentry_t *s, treenode *ex)
{
	if (!ex) return 0;

	if (debug)
	printf("SZ %s, %s <%s>\n", s->nme->str, name_of_node(ex->hdr.type), x_stmnt(ex));

	if (ex->hdr.type == TN_IDENT
	&&  ex->syment == s)
		return 0;	/* s */

	if (ex->hdr.type != TN_EXPR)
		return 0;

	if (ex->hdr.tok == AND)
		return simple_zero(s, ex->lnode)
		||     simple_zero(s, ex->rnode);

	if (ex->hdr.tok == OR)
		return simple_zero(s, ex->lnode)
		&&     simple_zero(s, ex->rnode);

	if (ex->hdr.tok == NOT
	&&  ex->lnode == ZT
	&&  ex->rnode->hdr.type == TN_IDENT
	&&  ex->rnode->syment == s)
		return 1;	/* !s */

	if (ex->hdr.tok == NOT
	&&  ex->lnode == ZT
	&&  ex->rnode->hdr.type == TN_EXPR
	&&  ex->rnode->hdr.tok == NOT_EQ
	&&  ex->rnode->lnode->hdr.type == TN_IDENT
	&&  ex->rnode->lnode->syment == s
	&&  is_zero_val(ex->rnode->rnode))
		return 1;	/* !(s != 0) */

	if (ex->hdr.tok == EQUAL
	&&  ex->lnode
	&&  ex->lnode->hdr.type == TN_IDENT
	&&  ex->lnode->syment == s
	&&  is_zero_val(ex->rnode))
		return 1;	/* (s == 0) */

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %r14, %r14
je 0x16a6b
cmpl $0x28, 0x1c(%r14)
jne 0x16a6b
movl 0x18(%r14), %eax
cmpl $0x150, %eax            # imm = 0x150
je 0x169d0
cmpl $0x151, %eax            # imm = 0x151
jne 0x169f1
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x16989
testl %eax, %eax
je 0x169eb
jmp 0x16a3f
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x16989
movl %eax, %ecx
movl $0x0, %eax
testl %ecx, %ecx
je 0x16a6b
movq 0x48(%r14), %r14
jmp 0x16996
cmpl $0x137, %eax            # imm = 0x137
je 0x16a43
cmpl $0x162, %eax            # imm = 0x162
jne 0x16a69
cmpq $0x0, 0x40(%r14)
jne 0x16a69
movq 0x48(%r14), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x16a16
cmpq %rbx, 0x38(%rax)
je 0x16a3f
movq 0x48(%r14), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x16a69
cmpl $0x13a, 0x18(%rax)      # imm = 0x13A
jne 0x16a69
movq 0x40(%rax), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x16a69
cmpq %rbx, 0x38(%rcx)
jne 0x16a69
movq 0x48(%rax), %rdi
jmp 0x16a5c
movl %ebp, %eax
jmp 0x16a6b
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x16a69
cmpl $0x2d, 0x1c(%rax)
jne 0x16a69
cmpq %rbx, 0x38(%rax)
jne 0x16a69
movq 0x48(%r14), %rdi
callq 0x12892
movl %eax, %ecx
movl %ebp, %eax
testl %ecx, %ecx
jne 0x16a6b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x207e1(%rip), %rax     # 0x3725c
cmpl $0x0, (%rax)
jne 0x16acd
movl %edx, %ebx
movq %rsi, %r14
movq 0x583cc(%rip), %rax     # 0x6ee58
addq $0x30, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x16aa9
cmpq %rdi, (%rax)
jne 0x16aa3
cmpq %r14, 0x8(%rax)
je 0x16aca
addq $0x18, %rax
jmp 0x16a90
callq 0x126c5
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x5839c(%rip), %rcx     # 0x6ee58
movq 0x30(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x30(%rcx)
jmp 0x16acd
orl %ebx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: mark_locs
static void
mark_locs(symentry_t *t, treenode *n, int status)
{	Graphs *g;
	SymRef *r;

	if (debug)
	printf("%d: mark_locs %s -- status %d\n",
	n->hdr.line, t->nme->str, status);

	for (r = curgraph->locs; r; r = r->nxt)
		if (r->sm == t)
		{	r->status |= status;	/* was: = (status & ~FCALL); */

			if (n && (status & USEbeforedef))
				r->n = n;
			return;
		}

	if (! ((status & USE) || (status & FCALL)))	/* missed braces to group !() */
		return;

	for (g = graph; g; g = g->nxt)
	{	if (strcmp(t->nme->str, g->fctnm) == 0)
		{	Gst *k;
			if (debug)
			printf("uno: status %d old status %d, decl_level %d marking %s at %s:%d as hide\n",
				status, g->status, t->decl_level,
				t->nme->str, n->hdr.fnm, n->hdr.line);

			g->status |= 4;		/* cannot tell when this fct is called */
			add_fcall(t, n, USE|HIDE);	/* ptr to fct name */

			if (Verbose)
			{	static int warned;
				if (!warned)
				{	warned++;
					printf("%s:%d fct %s is called via ptr\n",
						n->hdr.fnm, n->hdr.line, t->nme->str);
			}	}

			k = (Gst *) emalloc(sizeof(Gst));
			k->gnm = find_graph(t->nme->str);
			k->nxt = frst;
			frst = k;

			break;
	}	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58371(%rip), %rax     # 0x6ee58
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x16afe
cmpq %rbx, (%rax)
je 0x16b34
addq $0x18, %rax
jmp 0x16aeb
testb $0x6, %dl
je 0x16bc3
leaq 0x5836a(%rip), %r15     # 0x6ee78
movq (%r15), %r15
testq %r15, %r15
je 0x16bc3
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
movq (%r15), %rsi
callq 0x3190
testl %eax, %eax
je 0x16b47
addq $0x48, %r15
jmp 0x16b0e
orl %edx, 0x10(%rax)
btl $0xc, %edx
jae 0x16bc3
movq %r14, 0x8(%rax)
jmp 0x16bc3
orb $0x4, 0x42(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x160f9
leaq 0x206d5(%rip), %rax     # 0x37238
cmpl $0x0, (%rax)
je 0x16b96
testb $0x1, 0x583e9(%rip)     # 0x6ef58
jne 0x16b96
movb $0x1, 0x583e0(%rip)     # 0x6ef58
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x17628(%rip), %rdi     # 0x2e1b7
xorl %eax, %eax
callq 0x3100
pushq $0x10
popq %rdi
callq 0x4da5
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x16c15
movq %rax, (%r14)
movq 0x583a8(%rip), %rax     # 0x6ef60
movq %rax, 0x8(%r14)
movq %r14, 0x5839d(%rip)     # 0x6ef60
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x58358(%rip), %rax     # 0x6ef28
testq %rax, %rax
je 0x16c14
xorl %edx, %edx
movq %rax, %rsi
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x16c14
cmpq %rdi, (%rcx)
je 0x16bf0
leaq 0x18(%rcx), %rsi
movq %rcx, %rdx
jmp 0x16bda
leaq 0x18(%rdx), %rsi
testq %rdx, %rdx
movq 0x18(%rcx), %rdx
cmoveq %rax, %rsi
movq %rdx, (%rsi)
movq 0x58257(%rip), %rax     # 0x6ee60
movq %rax, 0x18(%rcx)
movq %rcx, 0x5824c(%rip)     # 0x6ee60
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x58254(%rip), %rbx     # 0x6ee78
movq 0x5825d(%rip), %r15     # 0x6ee88
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x16c4d
cmpq %r15, %rbx
je 0x16c47
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3190
testl %eax, %eax
je 0x16c4d
addq $0x48, %rbx
jmp 0x16c2b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x712c(%rip), %r12      # 0x1dd9c
testq %rbx, %rbx
je 0x16ca7
cmpl %ebp, 0x10(%rbx)
jne 0x16ca1
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rdx), %r8
movl 0x10(%rdx), %r9d
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
movq 0x18(%rbx), %rbx
jmp 0x16c70
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x740b(%rip), %rsi      # 0x1e0d3
movq %r14, %rdi
callq 0x3190
testl %eax, %eax
je 0x16d41
movq 0x202f5(%rip), %r12     # 0x36fd0
movq (%r12), %rcx
leaq 0x16fbb(%rip), %rdi     # 0x2dca1
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x3280
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x16d13
movq (%r12), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
leaq 0x17711(%rip), %rsi     # 0x2e41d
xorl %eax, %eax
callq 0x31a0
movq (%r12), %rdi
movq (%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x176b4(%rip), %rsi     # 0x2e3dd
movq %r14, %rdx
movq %rbx, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31a0
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x1768a(%rip), %rsi     # 0x2e3da
callq 0x3290
testq %rax, %rax
je 0x16cd4
cmpb $0x2e, (%rax)
jne 0x16cd4
cmpb $0x68, 0x1(%rax)
jne 0x16cd4
cmpb $0x0, 0x2(%rax)
jne 0x16cd4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: fct_details
static void
fct_details(FILE *fd, State *s)
{	Trans *t;
	State *ns;
	treenode *exp = (treenode *) 0;

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

	s->visited = 1;

	if (s->n->hdr.type == TN_IF)
		exp = ((if_node *)s->n)->cond;
	else if (s->n->hdr.type != TN_LABEL)
		exp = s->n;

	for (t = s->succ; t; t = t->nxt)
	{	ns = t->branch;
		if (!ns || !ns->n)
		{	if (exp)
				fprintf(fd, ">0>\n[%s]\n<%lu<\n",
				x_stmnt(exp), s->uno_state);
			continue;
		}
		if (ns->visited)
			fprintf(fd, "{%lu}\n", ns->uno_state);
		else
		{	ns->uno_state = Cnt++;
			fprintf(fd, ">%lu>\n", ns->uno_state);
		}
		fprintf(fd, "[%s", x_stmnt(exp));
		if (t->cond) fprintf(fd, " == %s", x_stmnt(t->cond));
		fprintf(fd, "]\n");
		fct_details(fd, ns);
		fprintf(fd, "<%lu<\n", s->uno_state);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x16db7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x16da9
cmpw $0x0, 0x4a(%rbx)
je 0x16db8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movw $0x1, 0x4a(%rbx)
movl 0x1c(%r15), %eax
cmpl $0x22, %eax
je 0x16dd5
cmpl $0x1b, %eax
jne 0x16dd8
movq 0x40(%r15), %r15
jmp 0x16dd8
xorl %r15d, %r15d
leaq 0x50(%rbx), %rbp
leaq 0x1769b(%rip), %r13     # 0x2e47e
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x16da9
movq 0x10(%rbp), %r12
testq %r12, %r12
je 0x16e16
cmpq $0x0, (%r12)
je 0x16e16
cmpw $0x0, 0x4a(%r12)
je 0x16e44
movq 0x40(%r12), %rdx
movq %r14, %rdi
leaq 0x17671(%rip), %rsi     # 0x2e485
jmp 0x16e65
testq %r15, %r15
je 0x16edb
movq %r15, %rdi
callq 0x4ac7
movq 0x40(%rbx), %rcx
movq %r14, %rdi
leaq 0x17640(%rip), %rsi     # 0x2e475
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x16edb
movq 0x20355(%rip), %rdx     # 0x371a0
leaq 0x1(%rdx), %rax
movq %rax, 0x2034a(%rip)     # 0x371a0
movq %rdx, 0x40(%r12)
movq %r14, %rdi
leaq 0x17627(%rip), %rsi     # 0x2e48c
xorl %eax, %eax
callq 0x31a0
movq %r15, %rdi
callq 0x4ac7
movq %r14, %rdi
leaq 0x17615(%rip), %rsi     # 0x2e493
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x16eaa
callq 0x4ac7
movq %r14, %rdi
leaq 0x175f7(%rip), %rsi     # 0x2e497
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
leaq 0x175ee(%rip), %rdi     # 0x2e49f
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x3280
movq %r14, %rdi
movq %r12, %rsi
callq 0x16d87
movq 0x40(%rbx), %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x31a0
addq $0x18, %rbp
jmp 0x16de3
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x16fe1
movq %rsi, %r14
cmpq $0x0, (%rsi)
je 0x16fe1
movq %rdi, %rbx
cmpw $0x0, 0x4a(%r14)
je 0x16f2d
movq 0x40(%r14), %rdx
leaq 0x1756d(%rip), %rsi     # 0x2e485
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31a0
movw $0x1, 0x4a(%r14)
movq 0x20265(%rip), %rdx     # 0x371a0
leaq 0x1(%rdx), %rax
movq %rax, 0x2025a(%rip)     # 0x371a0
movq %rdx, 0x40(%r14)
leaq 0x1753b(%rip), %rsi     # 0x2e48c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31a0
movq (%r14), %r12
cmpq $0x0, 0x20(%r12)
jne 0x16f7e
leaq 0x17531(%rip), %rdi     # 0x2e49e
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3280
movq (%r14), %r12
addq $0x20, %r12
leaq 0x17519(%rip), %r15     # 0x2e4a2
movq (%r12), %r12
testq %r12, %r12
je 0x16fa9
movq (%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
addq $0x8, %r12
jmp 0x16f89
leaq 0x58(%r14), %r12
leaq 0x174ca(%rip), %r15     # 0x2e47e
movq (%r12), %r12
testq %r12, %r12
je 0x16fe1
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x16ee4
movq 0x40(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
addq $0x18, %r12
jmp 0x16fb4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x1704e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x17049
cmpw $0x0, 0x4a(%r14)
jne 0x17049
movq %rdi, %rbx
movw $0x1, 0x4a(%r14)
cmpq $0x0, 0x20(%rax)
je 0x1704f
addq $0x58, %rbx
movq %rbx, %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x17036
leaq 0x18(%rcx), %rax
cmpq %r14, 0x10(%rcx)
jne 0x17022
jmp 0x17049
callq 0x14b3d
movq %r14, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x1701b
cmpq $0x0, 0x10(%r15)
je 0x1701b
testq %r15, %r15
je 0x17049
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x16fed
movq 0x18(%r15), %r15
jmp 0x1705f
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
pushq $0x1
popq %rbp
testq %rdi, %rdi
je 0x17eb0
leaq 0x1f3c9(%rip), %rax     # 0x3724c
cmpl $0x0, (%rax)
je 0x17eb0
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x17eb0
leaq 0x1f3a0(%rip), %rcx     # 0x37238
xorl %eax, %eax
cmpl $0x0, (%rcx)
jne 0x17eb2
cmpb $0x2e, (%rbx)
jne 0x17eb9
cmpb $0x2f, 0x1(%rbx)
jne 0x17eb9
cmpb $0x5f, 0x2(%rbx)
jne 0x17eb9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x15dbe(%rip), %rsi     # 0x2dc7e
pushq $0xc
popq %rdx
movq %rbx, %rdi
callq 0x3080
movl %eax, %ecx
movl %ebp, %eax
testl %ecx, %ecx
je 0x17eb2
leaq 0x166de(%rip), %rsi     # 0x2e5b8
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3080
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x17eb2
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %rbx, %rbx
je 0x17f9c
movl 0x1c(%rbx), %ecx
cmpl $0x21, %ecx
je 0x17f9c
movl (%rbx), %edx
cmpl $0x4, %edx
je 0x17f6b
cmpl $0x1, %edx
jne 0x17f79
jmp 0x17f9c
cmpl $0x22, %ecx
jne 0x17f79
movq 0x40(%rbx), %rcx
cmpl $0x1, (%rcx)
je 0x17f90
movq 0x48(%rbx), %rdi
callq 0x17f45
testl %eax, %eax
jne 0x17f8c
movq 0x40(%rbx), %rbx
jmp 0x17f4e
movl %ebp, %eax
jmp 0x17f9c
xorl %eax, %eax
cmpl $0x113, 0x18(%rcx)      # imm = 0x113
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpl $0x14, 0x1c(%rdi)
jne 0x17fce
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x17fed
xorl %eax, %eax
cmpl $0x1, (%rcx)
jne 0x17fcc
cmpl $0x2e, 0x1c(%rcx)
jne 0x17fcc
xorl %eax, %eax
cmpl $0x118, 0x18(%rcx)      # imm = 0x118
sete %al
popq %rcx
retq
leaq 0x165ec(%rip), %rdi     # 0x2e5c1
leaq 0x165ff(%rip), %rsi     # 0x2e5db
leaq 0x16602(%rip), %rcx     # 0x2e5e5
movl $0x297, %edx            # imm = 0x297
callq 0x3130
leaq 0x1660c(%rip), %rdi     # 0x2e600
leaq 0x165e0(%rip), %rsi     # 0x2e5db
leaq 0x165e3(%rip), %rcx     # 0x2e5e5
movl $0x298, %edx            # imm = 0x298
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x14, 0x1c(%rdi)
jne 0x18036
movq 0x40(%rdi), %rcx
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x18024
cmpl $0x18, 0x1c(%rcx)
jne 0x18035
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x18033
cmpl $0x18, 0x1c(%rcx)
jne 0x18035
xorl %eax, %eax
retq
pushq %rax
leaq 0x16583(%rip), %rdi     # 0x2e5c1
leaq 0x16596(%rip), %rsi     # 0x2e5db
leaq 0x165c5(%rip), %rcx     # 0x2e611
movl $0x2a3, %edx            # imm = 0x2A3
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/explore.c
// Function: has_lower_case
static char *
has_lower_case(treenode *n)
{	char *ptr;

	if (!n || n->hdr.warned)
	{	return NULL;
	}

	if (B_TYPE(n) == LEAF_T)
	{	if (W_TYPE(n) == TN_IDENT)
		{	char *p = ((leafnode *)n)->data.sval->str;
			while (*p != '\0')
			{	if (islower((int) *p++))
				{	n->hdr.warned++;
					return ((leafnode *)n)->data.sval->str;
		}	}	}
		return NULL;
	}

	if ((ptr = has_lower_case(n->lnode)) != NULL)
	{	n->hdr.warned++;
		return ptr;
	}
	return has_lower_case(n->rnode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x18460
cmpl $0x0, 0x30(%r14)
jne 0x18460
cmpl $0x1, (%r14)
je 0x1841d
movq 0x40(%r14), %rdi
callq 0x183ea
testq %rax, %rax
jne 0x18455
movq 0x48(%r14), %r14
jmp 0x183f7
cmpl $0x2d, 0x1c(%r14)
jne 0x1845e
movq 0x40(%r14), %rax
movq 0x8(%rax), %rbx
movq %rbx, %r15
movsbq (%r15), %r12
testq %r12, %r12
je 0x1845e
callq 0x32a0
movq (%rax), %rax
incq %r15
testb $0x2, 0x1(%rax,%r12,2)
je 0x1842f
movl $0x1, 0x30(%r14)
jmp 0x18460
incl 0x30(%r14)
movq %rax, %rbx
jmp 0x18460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_bounds.c
// Function: has_node_comp_ops
int
has_node_comp_ops(treenode *n)
{
	if (!n)
		return 0;

	if (n->hdr.type == (unsigned int) TN_EXPR)
	{	switch (n->hdr.tok) {
		case NOT:
		case EQUAL:
		case LESS:
		case LESS_EQ:
		case GRTR:
		case GRTR_EQ:
		case NOT_EQ:
		case AND:
		case OR:
		case B_NOT_EQ:	return 1;

		default:	return 0;
	}	}

	if (n->hdr.type == TN_EMPTY
	||  n->hdr.which == LEAF_T
	||  n->hdr.type == TN_IDENT)
	{	return 0;
	}

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %rbx, %rbx
je 0x184d7
movl 0x1c(%rbx), %ecx
testl %ecx, %ecx
je 0x184ae
cmpl $0x28, %ecx
je 0x184b2
cmpl $0x2d, %ecx
je 0x184d7
cmpl $0x1, (%rbx)
movl $0x0, %eax
je 0x184d7
movq 0x40(%rbx), %rdi
callq 0x18470
testl %eax, %eax
jne 0x184d5
movq 0x48(%rbx), %rbx
jmp 0x18479
movl %ecx, %eax
jmp 0x184d7
movl $0xfffffecf, %eax       # imm = 0xFFFFFECF
addl 0x18(%rbx), %eax
cmpl $0x31, %eax
ja 0x184d1
movabsq $0x200c1800003c1, %rcx  # imm = 0x200C1800003C1
btq %rax, %rcx
movl %ebp, %eax
jb 0x184d7
xorl %eax, %eax
jmp 0x184d7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq