LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: zero_test
int
zero_test(treenode *ex)	/* true if condition ex is a simple comparison against 0 */
{
	if (!ex) return 0;

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

	if (ex->hdr.type != TN_EXPR
	||  ex->hdr.tok == AND
	||  ex->hdr.tok == OR)
		return 0;

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

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

		if (ex->rnode->hdr.type == TN_EXPR
		&&  ex->rnode->hdr.tok == EQUAL
		&&  ex->rnode->lnode
		&&  ex->rnode->lnode->hdr.type == TN_IDENT
		&&  is_zero_val(ex->rnode->rnode))
			return 1;	/* !(s == 0) */
	} else {
		if ((ex->hdr.tok == EQUAL || ex->hdr.tok == NOT_EQ)
		&&  ex->lnode
		&&  ex->lnode->hdr.type == TN_IDENT
		&&  is_zero_val(ex->rnode))
			return 1;	/* (s == 0) or (s != 0) */
	}
	return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x13b60
movl 0x1c(%rdi), %ecx
cmpl $0x2d, %ecx
je 0x13b61
cmpl $0x28, %ecx
jne 0x13b60
movl 0x18(%rdi), %ecx
cmpl $0x14f, %ecx            # imm = 0x14F
jle 0x13ae5
leal -0x150(%rcx), %edx
cmpl $0x2, %edx
jb 0x13b60
cmpl $0x162, %ecx            # imm = 0x162
jne 0x13b5e
cmpq $0x0, 0x40(%rdi)
jne 0x13b5e
movq 0x48(%rdi), %rax
movl 0x1c(%rax), %ecx
cmpl $0x2d, %ecx
je 0x13b61
cmpl $0x28, %ecx
jne 0x13b5e
movl 0x18(%rax), %ecx
cmpl $0x137, %ecx            # imm = 0x137
je 0x13b2e
cmpl $0x13a, %ecx            # imm = 0x13A
jne 0x13b5e
movq 0x40(%rax), %rdx
testq %rdx, %rdx
je 0x13b5e
cmpl $0x2d, 0x1c(%rdx)
jne 0x13b5e
movq 0x48(%rax), %rdx
testq %rdx, %rdx
je 0x13b5e
movl 0x1c(%rdx), %esi
cmpl $0x1a, %esi
jne 0x13b1b
movq 0x48(%rdx), %rdx
testq %rdx, %rdx
jne 0x13ad2
jmp 0x13b26
cmpl $0x137, %ecx            # imm = 0x137
je 0x13af5
cmpl $0x13a, %ecx            # imm = 0x13A
jne 0x13b5e
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x13b5e
cmpl $0x2d, 0x1c(%rax)
jne 0x13b5e
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x13b5e
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
jne 0x13b4e
movq 0x48(%rax), %rax
jmp 0x13b08
cmpl $0x30, %esi
jne 0x13b26
cmpl $0x0, 0x40(%rdx)
je 0x13b61
cmpl $0x137, %ecx            # imm = 0x137
jne 0x13b5e
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x13b5e
cmpl $0x2d, 0x1c(%rcx)
jne 0x13b5e
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x13b5e
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
je 0x13b3d
cmpl $0x30, %ecx
jne 0x13b5e
cmpl $0x0, 0x40(%rax)
movl $0x1, %eax
je 0x13b60
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_graph
static Graphs *
rel_graph(Graphs *g)
{
	if (g)
	{	rel_graph(g->nxt);
		g->all = rel_state(g->all);
		g->fcalls  = rel_symext(g->fcalls);
		g->suspect = rel_symext(g->suspect);
		g->def_use = rel_symref(g->def_use);
		g->locs = rel_symref(g->locs);

		g->nxt = freegraph;
		freegraph = g;
	}
	return (Graphs *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x15054
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x14fe2
movq 0x10(%rbx), %rdi
callq 0x16785
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x28(%rbx), %rdi
callq 0x167f8
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x167f8
movq %r14, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x1681e
movq %r14, 0x18(%rbx)
movq 0x20(%rbx), %rdi
callq 0x1681e
movq %r14, 0x20(%rbx)
movq 0x5ae86(%rip), %rax     # 0x6fec8
movq %rax, 0x48(%rbx)
movq %rbx, 0x5ae7b(%rip)     # 0x6fec8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_label
static LNode *
rel_label(LNode *n)
{
	if (n)
	{	rel_label(n->nxt);
		n->nxt = freelabels;
		freelabels = n;
	}
	return (LNode *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1507a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x15055
movq 0x5ae7a(%rip), %rax     # 0x6fee8
movq %rax, 0x18(%rbx)
movq %rbx, 0x5ae6f(%rip)     # 0x6fee8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_sframe
static Stack *
rel_sframe(Stack *f)
{
	if (f)
	{	rel_sframe(f->nxt);
		f->nxt = fol;
		fol = f;
	}
	return (Stack *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x150a0
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1507b
movq 0x5ae5c(%rip), %rax     # 0x6fef0
movq %rax, 0x10(%rbx)
movq %rbx, 0x5ae51(%rip)     # 0x6fef0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_state
static State *
rel_state(State *s)
{
	if (s)
	{	rel_state(s->all);
		s->gi = rel_symref(s->gi);
		s->il = rel_symref(s->il);
		s->snapshot = rel_symref(s->snapshot);
		s->succ = rel_trans(s->succ);
		s->direct = rel_trans(s->direct);

		s->all = freestate;
		freestate = s;
	}
	return (State *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x167f7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x16785
movq 0x10(%rbx), %rdi
callq 0x1681e
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x1681e
movq %r14, 0x18(%rbx)
movq 0x8(%rbx), %rdi
callq 0x1681e
movq %r14, 0x8(%rbx)
movq 0x50(%rbx), %rdi
callq 0x16844
movq %r14, 0x50(%rbx)
movq 0x58(%rbx), %rdi
callq 0x16844
movq %r14, 0x58(%rbx)
movq 0x596eb(%rip), %rax     # 0x6fed0
movq %rax, 0x68(%rbx)
movq %rbx, 0x596e0(%rip)     # 0x6fed0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_symext
static SymExt *
rel_symext(SymExt *s)
{
	if (s)
	{	rel_symext(s->nxt);
		s->nxt = freesymext;
		freesymext = s;
	}
	return (SymExt *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1681d
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x167f8
movq 0x5965f(%rip), %rax     # 0x6fe70
movq %rax, 0x18(%rbx)
movq %rbx, 0x59654(%rip)     # 0x6fe70
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_symref
static SymRef *
rel_symref(SymRef *s)
{
	if (s)
	{	rel_symref(s->nxt);
		s->nxt = freesymref;
		freesymref = s;
	}
	return (SymRef *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x16843
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1681e
movq 0x596a9(%rip), %rax     # 0x6fee0
movq %rax, 0x18(%rbx)
movq %rbx, 0x5969e(%rip)     # 0x6fee0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_trans
static Trans *
rel_trans(Trans *t)
{
	if (t)
	{	rel_trans(t->nxt);
		t->knz = rel_symref(t->knz);
		t->nxt = freetrans;
		freetrans = t;
	}

	return (Trans *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1687a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x16844
movq 0x8(%rbx), %rdi
callq 0x1681e
movq $0x0, 0x8(%rbx)
movq 0x5966a(%rip), %rax     # 0x6fed8
movq %rax, 0x18(%rbx)
movq %rbx, 0x5965f(%rip)     # 0x6fed8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: create_state
static State *
create_state(Graphs *g)
{	State *s;

	if (freestate)
	{	s = freestate;
		freestate = s->all;
		memset(s, 0, sizeof(State));
	} else
		s = (State *) emalloc(sizeof(State));

	s->all = g->all;
	g->all = s;
	return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x5964a(%rip), %rax     # 0x6fed0
testq %rax, %rax
je 0x168b6
movq 0x68(%rax), %rcx
movq %rcx, 0x5963a(%rip)     # 0x6fed0
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x168c0
movl $0x70, %edi
callq 0x5fdd
movq 0x10(%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: mk_label_node
static treenode *
mk_label_node(leafnode *ident, treenode *n, char *s)
{	treenode *t;

	t = (treenode *) emalloc(sizeof(treenode));
	t->hdr.which = NODE_T;
	t->hdr.type = TN_LABEL;	/* just a place holder */
	t->hdr.tok = COLON;

	t->hdr.fnm = (char *) emalloc(strlen(n->hdr.fnm)+strlen(" after ''")+strlen(s)+1);
	sprintf(t->hdr.fnm, "%s after '%s'", n->hdr.fnm, s);

	t->hdr.line = n->hdr.line;
	t->lnode = (treenode *) ident;
	/* t->rnode -- normally points to stmnt labeled */
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x5fdd
movq %rax, %r12
movl $0x4, (%rax)
movabsq $0x220000014e, %rax     # imm = 0x220000014E
movq %rax, 0x18(%r12)
movq 0x8(%r14), %rdi
callq 0x30d0
movq %rax, %r13
movq %r15, %rdi
callq 0x30d0
leaq (%rax,%r13), %rdi
addq $0xa, %rdi
callq 0x5fdd
movq %rax, 0x8(%r12)
movq 0x8(%r14), %rdx
leaq 0x194e9(%rip), %rsi     # 0x2fe1c
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x3250
movl 0x10(%r14), %eax
movl %eax, 0x10(%r12)
movq %rbx, 0x40(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_push_start
static void
lts_push_start(treenode *n)
{	Stack *f;

	f = lts_new_stack();
	f->n = n;
	f->nxt = sol;
	sol = f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x5958a(%rip), %rax     # 0x6fef0
testq %rax, %rax
je 0x16980
movq 0x10(%rax), %rcx
movq %rcx, 0x5957a(%rip)     # 0x6fef0
movq $0x0, 0x10(%rax)
jmp 0x1698a
movl $0x18, %edi
callq 0x5fdd
movq %rbx, (%rax)
movq 0x5956c(%rip), %rcx     # 0x6ff00
movq %rcx, 0x10(%rax)
movq %rax, 0x59561(%rip)     # 0x6ff00
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_push_end
static void
lts_push_end(treenode *n)
{	Stack *f;

	f = lts_new_stack();
	f->status = 1;
	f->n = n;
	f->nxt = eol;
	eol = f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x59544(%rip), %rax     # 0x6fef0
testq %rax, %rax
je 0x169c6
movq 0x10(%rax), %rcx
movq %rcx, 0x59534(%rip)     # 0x6fef0
movq $0x0, 0x10(%rax)
jmp 0x169d0
movl $0x18, %edi
callq 0x5fdd
movl $0x1, 0x8(%rax)
movq %rbx, (%rax)
movq 0x59527(%rip), %rcx     # 0x6ff08
movq %rcx, 0x10(%rax)
movq %rax, 0x5951c(%rip)     # 0x6ff08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_seq
static State *
add_seq(State *cur, treenode *n)
{	State *s;

	if (!cur) return cur;

	uno_assert((n != NULL), "bad call of add_seq");

	s = create_state(curgraph);
	s->n = n;

	cur->nxt = s;
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x16a51
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %edi, %edi
testq %rsi, %rsi
setne %dil
leaq 0x19444(%rip), %rsi     # 0x2fe52
callq 0x1341d
movq 0x5943e(%rip), %r15     # 0x6fe58
movq 0x594af(%rip), %rax     # 0x6fed0
testq %rax, %rax
je 0x16a54
movq 0x68(%rax), %rcx
movq %rcx, 0x5949f(%rip)     # 0x6fed0
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x16a5e
xorl %eax, %eax
retq
movl $0x70, %edi
callq 0x5fdd
movq 0x10(%r15), %rcx
movq %rcx, 0x68(%rax)
movq %rax, 0x10(%r15)
movq %r14, (%rax)
movq %rax, 0x60(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: record_label
static void
record_label(treenode *s, State *n)	/* associate symentry with state in cfg */
{	LNode *ln;
	leafnode *x = (leafnode *) s;

	uno_assert((int) (x && n), "bad call to record_label");

	if (freelabels)
	{	ln = freelabels;
		freelabels = ln->nxt;
		memset(ln, 0, sizeof(LNode));
	} else
		ln = (LNode *) emalloc(sizeof(LNode));
	ln->s = x->data.sval->str;
	ln->f = curgraph?curgraph->fctnm:"_noname_";
	ln->n = n;
	ln->nxt = lnodes;
	lnodes = ln;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
movzbl %cl, %edi
leaq 0x193f0(%rip), %rsi     # 0x2fed7
callq 0x1341d
movq 0x593f5(%rip), %rax     # 0x6fee8
testq %rax, %rax
je 0x16b0f
movq 0x18(%rax), %rcx
movq %rcx, 0x593e5(%rip)     # 0x6fee8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x16b19
movl $0x20, %edi
callq 0x5fdd
movq 0x40(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq 0x5932d(%rip), %rcx     # 0x6fe58
testq %rcx, %rcx
je 0x16b35
movq (%rcx), %rcx
jmp 0x16b3c
leaq 0x193b4(%rip), %rcx     # 0x2fef0
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0x59355(%rip), %rcx     # 0x6fea0
movq %rcx, 0x18(%rax)
movq %rax, 0x5934a(%rip)     # 0x6fea0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: want_break
static void
want_break(treenode *n)
{	Stack *f;
	uno_assert((eol != NULL), "case outside switch");

	if (lintlike && !eol->status)	/* uno cannot tell that eol is nonzero */
	{	if (fol)
		{	f = fol;
			fol = fol->nxt;
			memset(f, 0, sizeof(Stack));
		} else
			f = (Stack *) emalloc(sizeof(Stack));
		f->n = n;
		f->nxt = fallthru;
		fallthru = f;
	}
	eol->status = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
cmpq $0x0, 0x5939c(%rip)     # 0x6ff08
setne %dil
leaq 0x19382(%rip), %rsi     # 0x2fef9
callq 0x1341d
leaq 0x216e1(%rip), %rax     # 0x38264
cmpl $0x0, (%rax)
movq 0x5937b(%rip), %rcx     # 0x6ff08
je 0x16be2
cmpl $0x0, 0x8(%rcx)
jne 0x16be2
movq 0x59354(%rip), %rax     # 0x6fef0
testq %rax, %rax
je 0x16bbc
movq 0x10(%rax), %rdx
movq %rdx, 0x59344(%rip)     # 0x6fef0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x16bcd
movl $0x18, %edi
callq 0x5fdd
movq 0x5933b(%rip), %rcx     # 0x6ff08
movq %rbx, (%rax)
movq 0x592d9(%rip), %rdx     # 0x6feb0
movq %rdx, 0x10(%rax)
movq %rax, 0x592ce(%rip)     # 0x6feb0
movl $0x0, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rbx), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
jne 0x16c1f
cmpl $0x140, 0x18(%rbx)      # imm = 0x140
jne 0x16cb7
movq 0x48(%rbx), %rdi
callq 0x16beb
testl %eax, %eax
jne 0x16c50
movq 0x40(%rbx), %rbx
jmp 0x16bf5
cmpl $0x3, %ecx
jne 0x16cb7
movq 0x40(%rbx), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x16cb7
movq 0x48(%rbx), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0x16c6f
movl 0x1c(%rax), %edx
cmpl $0xa, %edx
jne 0x16c57
movq 0x40(%rax), %rax
jmp 0x16c3d
movl $0x1, %eax
jmp 0x16cb7
cmpl $0x30, %edx
jne 0x16c6f
cmpl $0x1, (%rax)
movl $0x0, %r14d
jne 0x16c72
movl 0x40(%rax), %r14d
xorl %ebp, %ebp
jmp 0x16c72
xorl %r14d, %r14d
movq 0x591ef(%rip), %r15     # 0x6fe68
testq %r15, %r15
je 0x16cb5
movq 0x40(%rcx), %rax
movq 0x8(%rax), %rbx
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x3190
testl %eax, %eax
jne 0x16cac
movl $0x1, %eax
cmpl $0x0, 0x8(%r15)
je 0x16cb7
testb %bpl, %bpl
jne 0x16cac
cmpl %r14d, 0xc(%r15)
je 0x16cb7
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x16c86
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x16d56
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16da5
movq 0x5919e(%rip), %rax     # 0x6fe80
testq %rax, %rax
je 0x16cf6
cmpq %rbx, (%rax)
je 0x16daa
movq 0x8(%rax), %rax
jmp 0x16ce2
movl $0x10, %edi
callq 0x5fdd
movq %rbx, (%rax)
movq 0x59176(%rip), %rcx     # 0x6fe80
movq %rcx, 0x8(%rax)
movq %rax, 0x5916b(%rip)     # 0x6fe80
movq (%rbx), %rax
cmpl $0x4, (%rax)
jne 0x16d93
movl 0x1c(%rax), %ecx
leal -0x22(%rcx), %edx
cmpl $0x2, %edx
jb 0x16d5a
cmpl $0x4, %ecx
je 0x16d5a
cmpl $0x1d, %ecx
jne 0x16d93
cmpl $0x120, 0x18(%rax)      # imm = 0x120
je 0x16d93
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x16d93
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x16db1
movq %rax, %rdi
jmp 0x16d7a
xorl %ebx, %ebx
jmp 0x16da5
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x16d73
cmpq $0x0, 0x18(%rax)
movq %rbx, %rdi
jne 0x16d7a
addq $0x10, %rax
jmp 0x16d77
leaq 0x60(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
cmoveq %rbx, %rdi
cmpq %rbx, %rdi
je 0x16d90
callq 0x16cc2
movq %rax, %rbx
jmp 0x16d93
movq %rdi, %rbx
movq 0x590e6(%rip), %rax     # 0x6fe80
movq 0x8(%rax), %rax
movq %rax, 0x590db(%rip)     # 0x6fe80
movq %rbx, %rax
popq %rbx
retq
callq 0x4085
jmp 0x16da5
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_label_find
static State *
lts_label_find(char *s)
{	LNode *ln;

	uno_assert((s != NULL), "bad call to lts_label_find");

	for (ln = lnodes; ln; ln = ln->nxt)
		if (ln->s == s
		&&  ln->f == curgraph->fctnm)
		{	if (0)
			fprintf(stderr, "label match %s (N%p)\n", s, ln->n->n);
			return ln->n;
		}

	fprintf(stderr, "error: label %s not defined\n", s);
	return NS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x191d3(%rip), %rsi     # 0x2ff9b
callq 0x1341d
movq 0x590cc(%rip), %rax     # 0x6fea0
testq %rax, %rax
je 0x16df7
movq 0x59078(%rip), %rcx     # 0x6fe58
cmpq %rbx, (%rax)
jne 0x16dee
movq 0x8(%rax), %rdx
cmpq (%rcx), %rdx
je 0x16e17
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x16de0
movq 0x211fa(%rip), %rax     # 0x37ff8
movq (%rax), %rdi
leaq 0x191ae(%rip), %rsi     # 0x2ffb6
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x16e1b
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16e4d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16e45
cmpw $0x0, 0x4a(%rbx)
je 0x16e4e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, 0x4a(%rbx)
callq 0x5cbe
movq %rax, %r14
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
cmpl $0xc, %ecx
jle 0x16e76
cmpl $0xd, %ecx
je 0x16e7b
movb $0x27, %dl
cmpl $0x22, %ecx
je 0x16e7d
jmp 0x16e81
cmpl $0xa, %ecx
jne 0x16e8b
movb $0x20, %dl
movb %dl, (%r14,%rax)
cmpl $0x10, %eax
je 0x16e91
incq %rax
jmp 0x16e5e
testl %ecx, %ecx
jne 0x16e81
jmp 0x16e96
movb $0x0, (%r14,%rax)
movq (%rbx), %r15
movl 0x10(%r15), %ebp
movl 0x1c(%r15), %edi
callq 0x7937
leaq 0x19146(%rip), %rdi     # 0x2fff3
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 0x16ecc
movq 0x40(%rax), %rax
movq 0x28(%rax), %rdi
movq 0x210f9(%rip), %rax     # 0x37fd0
movq (%rax), %rsi
callq 0xfb03
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x16f0f
leaq 0x8eac(%rip), %r15      # 0x1fd9b
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a9b9
movl $0x2c, %edi
callq 0x3040
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x16eef
leaq 0x1957b(%rip), %rdi     # 0x30491
callq 0x30a0
movq 0x50(%rbx), %r12
testq %r12, %r12
je 0x16e45
leaq 0x190e0(%rip), %r14     # 0x3000f
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x16e45
movq (%rbx), %rsi
movq (%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x3100
movq %r15, %rdi
callq 0x16e26
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x16f2f
jmp 0x16e45
// File: /workspace/github_c_makefile_star2_O3/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 0x16f83
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16f7e
cmpw $0x0, 0x4a(%rbx)
je 0x16f84
popq %rbx
popq %r14
popq %r15
retq
movw $0x1, 0x4a(%rbx)
incl 0x58f94(%rip)           # 0x6ff24
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x16f7e
xorl %eax, %eax
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x16f7e
cmpw $0x0, 0x48(%rbx)
sete %cl
cmpq %rax, %r14
setne %al
orb %cl, %al
movzbl %al, %eax
addl 0x58f63(%rip), %eax     # 0x6ff20
movl %eax, 0x58f5d(%rip)     # 0x6ff20
movq (%rbx), %rcx
cmpl $0x1d, 0x1c(%rcx)
jne 0x16fd4
incl %eax
movl %eax, 0x58f4c(%rip)     # 0x6ff20
movq %r14, %rdi
callq 0x16f64
movq 0x18(%r15), %r15
movq %r14, %rax
testq %r15, %r15
jne 0x16f9b
jmp 0x16f7e
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rcx, %rcx
je 0x17893
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8546(%rip), %r12      # 0x1fd9c
cmpl %ebp, 0x10(%rbx)
jne 0x17882
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
testq %rbx, %rbx
jne 0x17856
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x178c7
movq %rdi, %r14
movq (%rdi), %r15
movq 0x585b5(%rip), %rbx     # 0x6fe60
testq %rbx, %rbx
je 0x178cb
movq 0x18(%rbx), %rax
movq %rax, 0x585a5(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x178d8
xorl %ebx, %ebx
jmp 0x178f8
movl $0x20, %edi
callq 0x5fdd
movq %rax, %rbx
movq %r15, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x17894
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1792a
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r14), %r15
movq %r15, %rdi
callq 0x17978
testl %eax, %eax
jne 0x1792e
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x17910
jmp 0x1796f
xorl %ebx, %ebx
jmp 0x1796f
movq 0x58603(%rip), %rbx     # 0x6ff38
testq %rbx, %rbx
je 0x17947
movq 0x10(%rbx), %rax
movq %rax, 0x585f3(%rip)     # 0x6ff38
jmp 0x17957
movl $0x18, %edi
callq 0x5fdd
movq %rax, %rbx
movq (%r14), %r15
movq %r15, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rdi
callq 0x17901
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x179fe
movq %rdi, %r14
movq 0x584ff(%rip), %r15     # 0x6fe90
movq 0x58590(%rip), %r12     # 0x6ff28
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x179db
testq %r15, %r15
je 0x179c2
movq %r15, %rcx
cmpq %rax, (%rcx)
je 0x179b9
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x179a9
jmp 0x179c2
testl $0xfffffffd, 0x10(%rcx) # imm = 0xFFFFFFFD
je 0x179f9
testq %r12, %r12
je 0x179db
movq (%r12), %rcx
testq %rcx, %rcx
je 0x179db
cmpq %rax, (%rcx)
je 0x179f9
movq 0x18(%rcx), %rcx
jmp 0x179cb
cmpl $0x1, (%r14)
je 0x179fe
movq 0x40(%r14), %rdi
callq 0x17978
testl %eax, %eax
jne 0x179f9
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x17998
jmp 0x179fe
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57dc1(%rip), %rax     # 0x6fe58
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x180ab
cmpq %r14, (%rax)
je 0x180ce
movq 0x18(%rax), %rax
jmp 0x1809b
movq 0x57dbe(%rip), %rax     # 0x6fe70
testq %rax, %rax
je 0x180da
movq 0x18(%rax), %rcx
movq %rcx, 0x57dae(%rip)     # 0x6fe70
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x180e4
testb $0x1, %bpl
je 0x180fe
movq %rbx, 0x8(%rax)
jmp 0x180fe
movl $0x20, %edi
callq 0x5fdd
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x57d66(%rip), %rcx     # 0x6fe58
movq 0x28(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x28(%rcx)
orl 0x10(%rax), %ebp
movl %ebp, 0x10(%rax)
cmpl $0x200, %ebp            # imm = 0x200
jg 0x18124
cmpl $0x1, %ebp
je 0x18145
cmpl $0x4, %ebp
je 0x1815c
cmpl $0x5, %ebp
jne 0x18157
leaq 0x18da3(%rip), %rdi     # 0x30ec5
jmp 0x1816c
cmpl $0x201, %ebp            # imm = 0x201
je 0x1814e
cmpl $0x204, %ebp            # imm = 0x204
je 0x18165
cmpl $0x205, %ebp            # imm = 0x205
jne 0x18157
leaq 0x17fd7(%rip), %rdi     # 0x3011a
jmp 0x1816c
leaq 0x16996(%rip), %rdi     # 0x2eae2
jmp 0x1816c
leaq 0x18252(%rip), %rdi     # 0x303a7
jmp 0x1816c
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7b5b(%rip), %rdi      # 0x1fcbe
jmp 0x1816c
leaq 0x17fac(%rip), %rdi     # 0x30118
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x18555
// File: /workspace/github_c_makefile_star2_O3/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 0x1866f
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 0x17221(%rip), %rsi     # 0x2f7ab
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3250
movq 0x8(%rbx), %r12
testq %r12, %r12
jne 0x185a8
leaq 0x7c61(%rip), %r12      # 0x20205
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 0x5fdd
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x7799(%rip), %r8       # 0x1fd9b
cmovneq %rax, %r8
leaq 0x17b0f(%rip), %rsi     # 0x3011c
movq %r12, %rdi
movq %r14, %rdx
movq %rsp, %r9
xorl %eax, %eax
callq 0x3250
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1863b
movq (%r14), %rdi
movq %r12, %rsi
callq 0x3190
testl %eax, %eax
je 0x18661
movq 0x8(%r14), %r14
jmp 0x18621
movl $0x10, %edi
callq 0x5fdd
movq %r12, (%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%rbx)
movq 0x577fd(%rip), %rax     # 0x6fe58
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_O3/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 0x62cd
testl %eax, %eax
jne 0x186eb
movq 0x5780b(%rip), %rax     # 0x6fe98
testq %rax, %rax
je 0x1869d
cmpq %r15, (%rax)
je 0x186c0
movq 0x18(%rax), %rax
jmp 0x1868d
movq 0x577bc(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x186c5
movq 0x18(%rax), %rcx
movq %rcx, 0x577ac(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x186cf
orl %ebx, 0x10(%rax)
jmp 0x186eb
movl $0x20, %edi
callq 0x5fdd
movq %r15, (%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x577b8(%rip), %rcx     # 0x6fe98
movq %rcx, 0x18(%rax)
movq %rax, 0x577ad(%rip)     # 0x6fe98
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x57565(%rip), %rax     # 0x6fe58
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18910
cmpq %r14, (%rax)
jne 0x188f3
orl %ebp, 0x10(%rax)
testb $0x40, %bpl
je 0x1895a
movq %rbx, 0x8(%rax)
jmp 0x1895a
movq 0x57549(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x18933
movq 0x18(%rax), %rcx
movq %rcx, 0x57539(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x1893d
movl $0x20, %edi
callq 0x5fdd
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x5750a(%rip), %rcx     # 0x6fe58
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x18(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x18a72
movq %rsi, %r15
movq %rdi, %r14
movl 0x1c(%r15), %eax
cmpl $0x28, %eax
jne 0x189c9
movl 0x18(%r15), %eax
cmpl $0x150, %eax            # imm = 0x150
jg 0x189a0
jne 0x189e0
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x1895f
testl %eax, %eax
jne 0x189bb
jmp 0x18a72
cmpl $0x151, %eax            # imm = 0x151
jne 0x18a17
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x1895f
testl %eax, %eax
jne 0x18a6d
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x18975
jmp 0x18a72
cmpl $0x2d, %eax
jne 0x18a72
xorl %ebx, %ebx
cmpq %r14, 0x38(%r15)
sete %bl
jmp 0x18a72
cmpl $0x13a, %eax            # imm = 0x13A
jne 0x18a72
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x18a72
cmpl $0x2d, 0x1c(%rax)
jne 0x18a72
cmpq %r14, 0x38(%rax)
jne 0x18a72
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x18a72
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
jne 0x18a62
movq 0x48(%rax), %rax
jmp 0x18a04
cmpl $0x162, %eax            # imm = 0x162
jne 0x18a72
cmpq $0x0, 0x40(%r15)
jne 0x18a72
movq 0x48(%r15), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x18a72
cmpl $0x137, 0x18(%rax)      # imm = 0x137
jne 0x18a72
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x18a72
cmpl $0x2d, 0x1c(%rcx)
jne 0x18a72
cmpq %r14, 0x38(%rcx)
jne 0x18a72
jmp 0x18a57
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
jne 0x18a62
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x18a4f
jmp 0x18a72
cmpl $0x30, %ecx
jne 0x18a72
cmpl $0x0, 0x40(%rax)
jne 0x18a72
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x18ab2
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %ebp
cmpq %r14, 0x38(%rbx)
je 0x18ab4
cmpl $0x1, (%rbx)
je 0x18ab2
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x18a7a
testl %eax, %eax
jne 0x18ab4
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
jne 0x18a8e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdx, %rdx
je 0x18af5
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %r15
leaq 0x17287(%rip), %rsi     # 0x2fd5d
movq %r15, %rdi
callq 0x3190
testl %eax, %eax
je 0x18afd
leaq 0x1726c(%rip), %rsi     # 0x2fd55
movq %r15, %rdi
callq 0x3190
testl %eax, %eax
je 0x18b0d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1895f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x18b1a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x18c2b
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x28, 0x1c(%r15)
jne 0x18c2b
movl 0x18(%r15), %eax
cmpl $0x150, %eax            # imm = 0x150
jg 0x18b61
jne 0x18bd5
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x18b1a
testl %eax, %eax
jne 0x18b7c
jmp 0x18c2b
cmpl $0x151, %eax            # imm = 0x151
jne 0x18b8a
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x18b1a
testl %eax, %eax
jne 0x18c26
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0x18b30
jmp 0x18c2b
cmpl $0x162, %eax            # imm = 0x162
jne 0x18c2b
cmpq $0x0, 0x40(%r15)
jne 0x18c2b
movq 0x48(%r15), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x18bb0
cmpq %r14, 0x38(%rax)
je 0x18c26
movq 0x48(%r15), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x18c2b
cmpl $0x13a, 0x18(%rax)      # imm = 0x13A
jne 0x18c2b
movq 0x40(%rax), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x18c2b
cmpq %r14, 0x38(%rcx)
jne 0x18c2b
jmp 0x18c10
cmpl $0x137, %eax            # imm = 0x137
jne 0x18c2b
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x18c2b
cmpl $0x2d, 0x1c(%rax)
jne 0x18c2b
cmpq %r14, 0x38(%rax)
jne 0x18c2b
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x18c2b
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
jne 0x18c1b
movq 0x48(%rax), %rax
jmp 0x18bf5
movl 0x1c(%rax), %ecx
cmpl $0x1a, %ecx
jne 0x18c1b
movq 0x48(%rax), %rax
testq %rax, %rax
jne 0x18c08
jmp 0x18c2b
cmpl $0x30, %ecx
jne 0x18c2b
cmpl $0x0, 0x40(%rax)
jne 0x18c2b
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
leaq 0x1f61d(%rip), %rax     # 0x3825c
cmpl $0x0, (%rax)
jne 0x18cb7
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x57205(%rip), %rax     # 0x6fe58
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x18c6d
cmpq %r15, (%rax)
jne 0x18c67
cmpq %r14, 0x8(%rax)
je 0x18cbd
movq 0x18(%rax), %rax
jmp 0x18c57
movq 0x571fc(%rip), %rax     # 0x6fe70
testq %rax, %rax
je 0x18c90
movq 0x18(%rax), %rcx
movq %rcx, 0x571ec(%rip)     # 0x6fe70
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x18c9a
movl $0x20, %edi
callq 0x5fdd
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x571ad(%rip), %rcx     # 0x6fe58
movq 0x30(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x30(%rcx)
popq %rbx
popq %r14
popq %r15
retq
orl %ebx, 0x10(%rax)
jmp 0x18cb7
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x57181(%rip), %rax     # 0x6fe58
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x18ceb
cmpq %rbx, (%rax)
je 0x18d2b
movq 0x18(%rax), %rax
jmp 0x18cdb
testb $0x6, %dl
je 0x18dbd
movq 0x5717d(%rip), %r12     # 0x6fe78
testq %r12, %r12
je 0x18dbd
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r15
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3190
testl %eax, %eax
je 0x18d3e
movq 0x48(%r12), %r12
testq %r12, %r12
jne 0x18d0c
jmp 0x18dbd
orl %edx, 0x10(%rax)
btl $0xc, %edx
jae 0x18dbd
movq %r14, 0x8(%rax)
jmp 0x18dbd
orb $0x4, 0x42(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x18084
leaq 0x1f4dd(%rip), %rax     # 0x38238
cmpl $0x0, (%rax)
je 0x18d8e
testb $0x1, 0x571f1(%rip)     # 0x6ff58
jne 0x18d8e
movb $0x1, 0x571e8(%rip)     # 0x6ff58
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x173fc(%rip), %rdi     # 0x30183
xorl %eax, %eax
callq 0x3100
movl $0x10, %edi
callq 0x5fdd
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x18e23
movq %rax, (%r14)
movq 0x571ae(%rip), %rax     # 0x6ff60
movq %rax, 0x8(%r14)
movq %r14, 0x571a3(%rip)     # 0x6ff60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57158(%rip), %rax     # 0x6ff28
testq %rax, %rax
je 0x18dfb
movq (%rax), %rcx
testq %rcx, %rcx
je 0x18dfb
cmpq %rdi, (%rcx)
je 0x18dfc
movq %rcx, %rdx
movq 0x18(%rdx), %rcx
testq %rcx, %rcx
je 0x18dfb
movq %rdx, %rsi
movq %rcx, %rdx
cmpq %rdi, (%rcx)
jne 0x18de5
jmp 0x18dfe
retq
xorl %esi, %esi
leaq 0x18(%rsi), %rdx
testq %rsi, %rsi
movq 0x18(%rcx), %rsi
cmoveq %rax, %rdx
movq %rsi, (%rdx)
movq 0x57049(%rip), %rax     # 0x6fe60
movq %rax, 0x18(%rcx)
movq %rcx, 0x5703e(%rip)     # 0x6fe60
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57049(%rip), %rbx     # 0x6fe78
testq %rbx, %rbx
je 0x18e5b
movq %rdi, %r14
movq 0x5704a(%rip), %r15     # 0x6fe88
cmpq %r15, %rbx
je 0x18e52
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3190
testl %eax, %eax
je 0x18e5d
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
jne 0x18e3e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rcx, %rcx
je 0x18ec2
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x6f17(%rip), %r12      # 0x1fd9c
cmpl %ebp, 0x10(%rbx)
jne 0x18eb1
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
testq %rbx, %rbx
jne 0x18e85
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq