LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_lts.c
// Function: infeasible
int
infeasible(treenode *e, treenode *v)
{	int w;
	char *s;

	if (!e || !v) return 0;

	if (e->hdr.type == TN_INT
	&&  v->hdr.tok  == IDENT)
	{	w = ((leafnode *)e)->data.ival;		/* could use const_expr evaluator here */
		s = ((leafnode *)v)->data.sval->str;

		if ((w != 0 && strcmp(s, "_false_") == 0)
		||  (w == 0 && strcmp(s,  "_true_") == 0))
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x14574
cmpl $0x30, 0x1c(%rdi)
jne 0x14574
cmpl $0x102, 0x18(%rsi)      # imm = 0x102
jne 0x14574
movq 0x40(%rsi), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x40(%rdi)
je 0x1455c
leaq 0x1b81e(%rip), %rsi     # 0x2fd78
jmp 0x14563
leaq 0x1b81d(%rip), %rsi     # 0x2fd80
movq %rax, %rdi
callq 0x3180
testl %eax, %eax
jne 0x14574
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
testq %rdi, %rdi
je 0x14678
movl 0x1c(%rdi), %ecx
cmpl $0x2d, %ecx
je 0x1464c
cmpl $0x28, %ecx
jne 0x14678
movl 0x18(%rdi), %ecx
cmpl $0x14f, %ecx            # imm = 0x14F
jle 0x145dd
leal -0x150(%rcx), %edx
cmpl $0x2, %edx
jb 0x14678
cmpl $0x162, %ecx            # imm = 0x162
jne 0x14676
cmpq $0x0, 0x40(%rdi)
je 0x14616
cmpl $0x13a, %ecx            # imm = 0x13A
je 0x145f1
cmpl $0x137, %ecx            # imm = 0x137
je 0x145f1
jmp 0x14676
cmpl $0x137, %ecx            # imm = 0x137
je 0x145f1
cmpl $0x13a, %ecx            # imm = 0x13A
jne 0x14676
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x14676
cmpl $0x2d, 0x1c(%rax)
jne 0x14676
movq 0x48(%rdi), %rdi
callq 0x1467f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x14678
jmp 0x14676
movq 0x48(%rdi), %rbx
movl 0x1c(%rbx), %ebp
cmpl $0x2d, %ebp
je 0x1464c
cmpl $0x28, %ebp
jne 0x14676
cmpl $0x13a, 0x18(%rbx)      # imm = 0x13A
jne 0x14653
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x14653
cmpl $0x2d, 0x1c(%rax)
jne 0x14653
movq 0x48(%rbx), %rdi
callq 0x1467f
testl %eax, %eax
je 0x14653
movl $0x1, %eax
jmp 0x14678
cmpl $0x28, %ebp
jne 0x14676
cmpl $0x137, 0x18(%rbx)      # imm = 0x137
jne 0x14676
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x14676
cmpl $0x2d, 0x1c(%rax)
jne 0x14676
movq 0x48(%rbx), %rdi
jmp 0x14604
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_lts.c
// Function: is_zero_val
static int
is_zero_val(treenode *n)
{
	if (!n) return 0;

	if (n->hdr.type == TN_CAST)
		return is_zero_val(n->rnode);

	return (n->hdr.type == TN_INT
		&&  ((leafnode *)n)->data.ival == 0);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x146a2
movl 0x1c(%rdi), %ecx
cmpl $0x1a, %ecx
jne 0x14694
movq 0x48(%rdi), %rdi
jmp 0x14681
cmpl $0x30, %ecx
jne 0x146a2
xorl %eax, %eax
cmpl $0x0, 0x40(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15b6c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x15afa
movq 0x10(%rbx), %rdi
callq 0x1686b
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x28(%rbx), %rdi
callq 0x168de
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x168de
movq %r14, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x16904
movq %r14, 0x18(%rbx)
movq 0x20(%rbx), %rdi
callq 0x16904
movq %r14, 0x20(%rbx)
movq 0x5a35e(%rip), %rax     # 0x6feb8
movq %rax, 0x48(%rbx)
movq %rbx, 0x5a353(%rip)     # 0x6feb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15b92
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x15b6d
movq 0x5a352(%rip), %rax     # 0x6fed8
movq %rax, 0x18(%rbx)
movq %rbx, 0x5a347(%rip)     # 0x6fed8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15bb8
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15b93
movq 0x5a334(%rip), %rax     # 0x6fee0
movq %rax, 0x10(%rbx)
movq %rbx, 0x5a329(%rip)     # 0x6fee0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x168dd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x1686b
movq 0x10(%rbx), %rdi
callq 0x16904
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x16904
movq %r14, 0x18(%rbx)
movq 0x8(%rbx), %rdi
callq 0x16904
movq %r14, 0x8(%rbx)
movq 0x50(%rbx), %rdi
callq 0x1692a
movq %r14, 0x50(%rbx)
movq 0x58(%rbx), %rdi
callq 0x1692a
movq %r14, 0x58(%rbx)
movq 0x595f5(%rip), %rax     # 0x6fec0
movq %rax, 0x68(%rbx)
movq %rbx, 0x595ea(%rip)     # 0x6fec0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16903
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x168de
movq 0x59569(%rip), %rax     # 0x6fe60
movq %rax, 0x18(%rbx)
movq %rbx, 0x5955e(%rip)     # 0x6fe60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16929
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x16904
movq 0x595b3(%rip), %rax     # 0x6fed0
movq %rax, 0x18(%rbx)
movq %rbx, 0x595a8(%rip)     # 0x6fed0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16960
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1692a
movq 0x8(%rbx), %rdi
callq 0x16904
movq $0x0, 0x8(%rbx)
movq 0x59574(%rip), %rax     # 0x6fec8
movq %rax, 0x18(%rbx)
movq %rbx, 0x59569(%rip)     # 0x6fec8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59554(%rip), %rax     # 0x6fec0
testq %rax, %rax
je 0x1699c
movq 0x68(%rax), %rcx
movq %rcx, 0x59544(%rip)     # 0x6fec0
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 0x169a6
movl $0x70, %edi
callq 0x61a1
movq 0x10(%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x61a1
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 0x61a1
movq %rax, 0x8(%r12)
movq 0x8(%r14), %rdx
leaq 0x19429(%rip), %rsi     # 0x2fe42
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x3240
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_O1/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 0x5945e(%rip), %rax     # 0x6fee0
testq %rax, %rax
je 0x16a9c
movq 0x10(%rax), %rcx
movq %rcx, 0x5944e(%rip)     # 0x6fee0
movq $0x0, 0x10(%rax)
jmp 0x16aa6
movl $0x18, %edi
callq 0x61a1
movq %rbx, (%rax)
movq 0x59440(%rip), %rcx     # 0x6fef0
movq %rcx, 0x10(%rax)
movq %rax, 0x59435(%rip)     # 0x6fef0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59418(%rip), %rax     # 0x6fee0
testq %rax, %rax
je 0x16ae2
movq 0x10(%rax), %rcx
movq %rcx, 0x59408(%rip)     # 0x6fee0
movq $0x0, 0x10(%rax)
jmp 0x16aec
movl $0x18, %edi
callq 0x61a1
movl $0x1, 0x8(%rax)
movq %rbx, (%rax)
movq 0x593fb(%rip), %rcx     # 0x6fef8
movq %rcx, 0x10(%rax)
movq %rax, 0x593f0(%rip)     # 0x6fef8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16b6d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %edi, %edi
testq %rsi, %rsi
setne %dil
leaq 0x1934e(%rip), %rsi     # 0x2fe78
callq 0x13f8c
movq 0x59312(%rip), %r15     # 0x6fe48
movq 0x59383(%rip), %rax     # 0x6fec0
testq %rax, %rax
je 0x16b70
movq 0x68(%rax), %rcx
movq %rcx, 0x59373(%rip)     # 0x6fec0
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 0x16b7a
xorl %eax, %eax
retq
movl $0x70, %edi
callq 0x61a1
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_O1/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 0x19302(%rip), %rsi     # 0x2fefd
callq 0x13f8c
movq 0x592d1(%rip), %rax     # 0x6fed8
testq %rax, %rax
je 0x16c23
movq 0x18(%rax), %rcx
movq %rcx, 0x592c1(%rip)     # 0x6fed8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x16c2d
movl $0x20, %edi
callq 0x61a1
movq 0x40(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq 0x59209(%rip), %rcx     # 0x6fe48
testq %rcx, %rcx
je 0x16c49
movq (%rcx), %rcx
jmp 0x16c50
leaq 0x192c6(%rip), %rcx     # 0x2ff16
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0x59231(%rip), %rcx     # 0x6fe90
movq %rcx, 0x18(%rax)
movq %rax, 0x59226(%rip)     # 0x6fe90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x59278(%rip)     # 0x6fef8
setne %dil
leaq 0x19294(%rip), %rsi     # 0x2ff1f
callq 0x13f8c
leaq 0x215bd(%rip), %rax     # 0x38254
cmpl $0x0, (%rax)
je 0x16cef
movq 0x59255(%rip), %rax     # 0x6fef8
cmpl $0x0, 0x8(%rax)
jne 0x16cef
movq 0x59230(%rip), %rax     # 0x6fee0
testq %rax, %rax
je 0x16cd0
movq 0x10(%rax), %rcx
movq %rcx, 0x59220(%rip)     # 0x6fee0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x16cda
movl $0x18, %edi
callq 0x61a1
movq %rbx, (%rax)
movq 0x591bc(%rip), %rcx     # 0x6fea0
movq %rcx, 0x10(%rax)
movq %rax, 0x591b1(%rip)     # 0x6fea0
movq 0x59202(%rip), %rax     # 0x6fef8
movl $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1761c
cmpl $0x140, 0x18(%rbx)      # imm = 0x140
jne 0x1761c
movq 0x48(%rbx), %rdi
callq 0x175ec
testl %eax, %eax
jne 0x1764d
movq 0x40(%rbx), %rbx
jmp 0x175f6
cmpl $0x3, %ecx
jne 0x176b4
movq 0x40(%rbx), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x176b4
movq 0x48(%rbx), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0x1766c
movl 0x1c(%rax), %edx
cmpl $0xa, %edx
jne 0x17654
movq 0x40(%rax), %rax
jmp 0x1763a
movl $0x1, %eax
jmp 0x176b4
cmpl $0x30, %edx
jne 0x1766c
cmpl $0x1, (%rax)
movl $0x0, %r14d
jne 0x1766f
movl 0x40(%rax), %r14d
xorl %ebp, %ebp
jmp 0x1766f
xorl %r14d, %r14d
movq 0x587e2(%rip), %r15     # 0x6fe58
testq %r15, %r15
je 0x176b2
movq 0x40(%rcx), %rax
movq 0x8(%rax), %rbx
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x3180
testl %eax, %eax
jne 0x176a9
movl $0x1, %eax
cmpl $0x0, 0x8(%r15)
je 0x176b4
testb %bpl, %bpl
jne 0x176a9
cmpl %r14d, 0xc(%r15)
je 0x176b4
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x17683
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x177a5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x177a5
movq 0x58791(%rip), %rax     # 0x6fe70
testq %rax, %rax
je 0x176f3
cmpq %rbx, (%rax)
je 0x177aa
movq 0x8(%rax), %rax
jmp 0x176df
movl $0x10, %edi
callq 0x61a1
movq %rbx, (%rax)
movq 0x58769(%rip), %rcx     # 0x6fe70
movq %rcx, 0x8(%rax)
movq %rax, 0x5875e(%rip)     # 0x6fe70
movq (%rbx), %rcx
cmpl $0x4, (%rcx)
movq %rbx, %rax
jne 0x17783
movl 0x1c(%rcx), %edx
leal -0x22(%rdx), %eax
cmpl $0x2, %eax
jb 0x1775c
cmpl $0x4, %edx
je 0x1775c
movq %rbx, %rax
cmpl $0x1d, %edx
jne 0x17783
cmpl $0x120, 0x18(%rcx)      # imm = 0x120
movq %rbx, %rax
je 0x17783
movq 0x40(%rcx), %rcx
movq %rbx, %rax
testq %rcx, %rcx
je 0x17783
movq 0x40(%rcx), %rax
movq 0x8(%rax), %rdi
callq 0x177b1
jmp 0x1777c
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x17775
cmpq $0x0, 0x18(%rcx)
movq %rbx, %rax
jne 0x1777c
addq $0x10, %rcx
jmp 0x17779
leaq 0x60(%rbx), %rcx
movq (%rcx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
cmpq %rbx, %rax
je 0x17790
movq %rax, %rdi
callq 0x176bf
movq 0x586d9(%rip), %rcx     # 0x6fe70
movq 0x8(%rcx), %rcx
movq %rcx, 0x586ce(%rip)     # 0x6fe70
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
callq 0x4208
jmp 0x177a5
// File: /workspace/github_c_makefile_star2_O1/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 0x187f9(%rip), %rsi     # 0x2ffc1
callq 0x13f8c
movq 0x586bc(%rip), %rax     # 0x6fe90
testq %rax, %rax
je 0x177f7
movq 0x58668(%rip), %rcx     # 0x6fe48
cmpq %rbx, (%rax)
jne 0x177ee
movq 0x8(%rax), %rdx
cmpq (%rcx), %rdx
je 0x17817
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x177e0
movq 0x207fa(%rip), %rax     # 0x37ff8
movq (%rax), %rdi
leaq 0x187d4(%rip), %rsi     # 0x2ffdc
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3190
jmp 0x1781b
movq 0x10(%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1784d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x17845
cmpw $0x0, 0x4a(%rbx)
je 0x1784e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, 0x4a(%rbx)
callq 0x5e8a
movq %rax, %r14
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
cmpl $0x22, %ecx
je 0x1786e
testl %ecx, %ecx
jne 0x17873
jmp 0x1789a
movb $0x27, (%r14,%rax)
cmpb $0xa, (%r14,%rax)
jne 0x1787f
movb $0x20, (%r14,%rax)
cmpb $0xd, (%r14,%rax)
jne 0x1788b
movb $0x20, (%r14,%rax)
cmpl $0x10, %eax
je 0x17895
incq %rax
jmp 0x1785e
movb $0x0, (%r14,%rax)
movq (%rbx), %r15
movl 0x10(%r15), %ebp
movl 0x1c(%r15), %edi
callq 0x7b0d
leaq 0x18768(%rip), %rdi     # 0x30019
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 0x178d0
movq 0x40(%rax), %rax
movq 0x28(%rax), %rdi
movq 0x206f5(%rip), %rax     # 0x37fd0
movq (%rax), %rsi
callq 0x106b4
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x17913
leaq 0x84c8(%rip), %r15      # 0x1fdbb
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1b2fb
movl $0x2c, %edi
callq 0x3040
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x178f3
leaq 0x18b9d(%rip), %rdi     # 0x304b7
callq 0x30a0
movq 0x50(%rbx), %r12
testq %r12, %r12
je 0x17845
leaq 0x18702(%rip), %r14     # 0x30035
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x17845
movq (%rbx), %rsi
movq (%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x3100
movq %r15, %rdi
callq 0x17826
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x17933
jmp 0x17845
// File: /workspace/github_c_makefile_star2_O1/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 0x17987
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x17982
cmpw $0x0, 0x4a(%rbx)
je 0x17988
popq %rbx
popq %r14
popq %r15
retq
movw $0x1, 0x4a(%rbx)
incl 0x58580(%rip)           # 0x6ff14
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x17982
xorl %eax, %eax
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x17982
movl 0x58562(%rip), %ecx     # 0x6ff10
leal 0x1(%rcx), %edx
movl %edx, 0x58559(%rip)     # 0x6ff10
cmpw $0x0, 0x48(%rbx)
cmovel %edx, %ecx
cmpq %rax, %r14
cmovnel %edx, %ecx
movl %ecx, 0x58545(%rip)     # 0x6ff10
movq (%rbx), %rax
cmpl $0x1d, 0x1c(%rax)
jne 0x179dc
incl %ecx
movl %ecx, 0x58534(%rip)     # 0x6ff10
movq %r14, %rdi
callq 0x17968
movq 0x18(%r15), %r15
movq %r14, %rax
testq %r15, %r15
jne 0x1799f
jmp 0x17982
// File: /workspace/github_c_makefile_star2_O1/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 0x18244
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7bb5(%rip), %r12      # 0x1fdbc
cmpl %ebp, 0x10(%rbx)
jne 0x18233
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 0x3190
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x18207
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18278
movq %rdi, %r14
movq (%rdi), %r15
movq 0x57bf4(%rip), %rbx     # 0x6fe50
testq %rbx, %rbx
je 0x1827c
movq 0x18(%rbx), %rax
movq %rax, 0x57be4(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x18289
xorl %ebx, %ebx
jmp 0x182af
movl $0x20, %edi
callq 0x61a1
movq %rax, %rbx
movq %r15, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x14(%r14), %eax
movl %eax, 0x14(%rbx)
movq 0x18(%r14), %rdi
callq 0x18245
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x182dd
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x1832d
testl %eax, %eax
jne 0x182e1
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x182c6
jmp 0x18322
xorl %ebx, %ebx
jmp 0x18322
movq 0x57c40(%rip), %rbx     # 0x6ff28
testq %rbx, %rbx
je 0x182fa
movq 0x10(%rbx), %rax
movq %rax, 0x57c30(%rip)     # 0x6ff28
jmp 0x18307
movl $0x18, %edi
callq 0x61a1
movq %rax, %rbx
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rdi
callq 0x182b8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x1839d
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0x18380
movq 0x57b38(%rip), %rdx     # 0x6fe80
testq %rdx, %rdx
je 0x18361
cmpq %rcx, (%rdx)
je 0x18358
movq 0x18(%rdx), %rdx
jmp 0x18348
testl $0xfffffffd, 0x10(%rdx) # imm = 0xFFFFFFFD
je 0x18398
movq 0x57bb0(%rip), %rdx     # 0x6ff18
testq %rdx, %rdx
je 0x18380
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x18380
cmpq %rcx, (%rdx)
je 0x18398
movq 0x18(%rdx), %rdx
jmp 0x18370
cmpl $0x1, (%rbx)
je 0x1839d
movq 0x40(%rbx), %rdi
callq 0x1832d
testl %eax, %eax
jne 0x18398
movq 0x48(%rbx), %rbx
jmp 0x18331
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57430(%rip), %rax     # 0x6fe48
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x18a2c
cmpq %r14, (%rax)
je 0x18a4f
movq 0x18(%rax), %rax
jmp 0x18a1c
movq 0x5742d(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x18a5b
movq 0x18(%rax), %rcx
movq %rcx, 0x5741d(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x18a65
testb $0x1, %bpl
je 0x18a7f
movq %rbx, 0x8(%rax)
jmp 0x18a7f
movl $0x20, %edi
callq 0x61a1
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x573d5(%rip), %rcx     # 0x6fe48
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 0x18aa5
cmpl $0x1, %ebp
je 0x18ac6
cmpl $0x4, %ebp
je 0x18add
cmpl $0x5, %ebp
jne 0x18ad8
leaq 0x1844a(%rip), %rdi     # 0x30eed
jmp 0x18aed
cmpl $0x201, %ebp            # imm = 0x201
je 0x18acf
cmpl $0x204, %ebp            # imm = 0x204
je 0x18ae6
cmpl $0x205, %ebp            # imm = 0x205
jne 0x18ad8
leaq 0x1767c(%rip), %rdi     # 0x30140
jmp 0x18aed
leaq 0x16048(%rip), %rdi     # 0x2eb15
jmp 0x18aed
leaq 0x178f7(%rip), %rdi     # 0x303cd
jmp 0x18aed
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7090(%rip), %rdi      # 0x1fb74
jmp 0x18aed
leaq 0x17651(%rip), %rdi     # 0x3013e
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x18ecf
// File: /workspace/github_c_makefile_star2_O1/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 0x18ff6
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 0x168db(%rip), %rsi     # 0x2f7df
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3240
cmpq $0x0, 0x8(%rbx)
jne 0x18f20
leaq 0x7307(%rip), %rax      # 0x20223
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x30d0
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x30d0
movq %rax, %rbp
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
leaq 0x6e72(%rip), %rax      # 0x1fdbb
cmoveq %rax, %rdi
callq 0x30d0
movq %rax, %r13
movq %rsp, %rdi
callq 0x30d0
addq %r12, %r13
addq %rbp, %r13
leaq (%rax,%r13), %rdi
addq $0x4, %rdi
callq 0x61a1
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %r8
testq %r8, %r8
leaq 0x6e32(%rip), %rax      # 0x1fdbb
cmoveq %rax, %r8
leaq 0x171ae(%rip), %rsi     # 0x30142
movq %r12, %rdi
movq %r14, %rdx
movq %rsp, %r9
xorl %eax, %eax
callq 0x3240
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x18fc2
movq (%r14), %rdi
movq %r12, %rsi
callq 0x3180
testl %eax, %eax
je 0x18fe8
movq 0x8(%r14), %r14
jmp 0x18fa8
movl $0x10, %edi
callq 0x61a1
movq %r12, (%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%rbx)
movq 0x56e66(%rip), %rax     # 0x6fe48
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_O1/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 0x64a2
testl %eax, %eax
jne 0x19072
movq 0x56e74(%rip), %rax     # 0x6fe88
testq %rax, %rax
je 0x19024
cmpq %r15, (%rax)
je 0x19047
movq 0x18(%rax), %rax
jmp 0x19014
movq 0x56e25(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x1904c
movq 0x18(%rax), %rcx
movq %rcx, 0x56e15(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x19056
orl %ebx, 0x10(%rax)
jmp 0x19072
movl $0x20, %edi
callq 0x61a1
movq %r15, (%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x56e21(%rip), %rcx     # 0x6fe88
movq %rcx, 0x18(%rax)
movq %rax, 0x56e16(%rip)     # 0x6fe88
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x56e83(%rip)     # 0x6ff18
setne %dil
leaq 0x170ae(%rip), %rsi     # 0x3014e
callq 0x13f8c
movq 0x56e6c(%rip), %rax     # 0x6ff18
movq 0x8(%rax), %rbp
testq %rbp, %rbp
je 0x190fb
movq 0x8(%r15), %rax
movq 0x8(%rax), %r12
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3180
testl %eax, %eax
jns 0x1911e
movq %rbp, %r13
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
je 0x1914d
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3180
testl %eax, %eax
js 0x190d5
jmp 0x19121
movq 0x56d4e(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x19170
movq 0x18(%rax), %rcx
movq %rcx, 0x56d3e(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x1917a
xorl %r13d, %r13d
testl %eax, %eax
je 0x19148
movq 0x56d24(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x19186
movq 0x18(%rax), %rcx
movq %rcx, 0x56d14(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x19190
orl %ebx, 0x10(%rbp)
jmp 0x191c8
movq 0x56cfc(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x191b0
movq 0x18(%rax), %rcx
movq %rcx, 0x56cec(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x191ba
movl $0x20, %edi
callq 0x61a1
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
jmp 0x191a3
movl $0x20, %edi
callq 0x61a1
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq %rbp, 0x18(%rax)
testq %r13, %r13
jne 0x191c4
movq 0x56d6e(%rip), %rcx     # 0x6ff18
movq %rax, 0x8(%rcx)
jmp 0x191c8
movl $0x20, %edi
callq 0x61a1
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq %rax, 0x18(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x56be8(%rip), %rax     # 0x6fe48
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1927d
cmpq %r14, (%rax)
jne 0x19260
orl %ebp, 0x10(%rax)
testb $0x40, %bpl
je 0x192c7
movq %rbx, 0x8(%rax)
jmp 0x192c7
movq 0x56bcc(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x192a0
movq 0x18(%rax), %rcx
movq %rcx, 0x56bbc(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x192aa
movl $0x20, %edi
callq 0x61a1
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x56b8d(%rip), %rcx     # 0x6fe48
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_O1/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, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rbx, %rbx
je 0x193a2
movl 0x1c(%rbx), %ecx
cmpl $0x28, %ecx
je 0x19301
cmpl $0x2d, %ecx
jne 0x193a2
cmpq %r14, 0x38(%rbx)
je 0x19345
cmpl $0x28, %ecx
jne 0x193a2
movl 0x18(%rbx), %ebp
cmpl $0x150, %ebp            # imm = 0x150
jg 0x19327
jne 0x19383
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x192cc
movl %eax, %ecx
movl $0x0, %eax
testl %ecx, %ecx
jne 0x1933f
jmp 0x193a2
cmpl $0x151, %ebp            # imm = 0x151
jne 0x1934c
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x192cc
testl %eax, %eax
jne 0x19345
movq 0x48(%rbx), %rbx
jmp 0x192d6
movl $0x1, %eax
jmp 0x193a2
cmpl $0x162, %ebp            # imm = 0x162
jne 0x193a0
cmpq $0x0, 0x40(%rbx)
jne 0x19383
movq 0x48(%rbx), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x19383
cmpl $0x137, 0x18(%rax)      # imm = 0x137
jne 0x19383
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x19383
cmpl $0x2d, 0x1c(%rcx)
jne 0x19383
cmpq %r14, 0x38(%rcx)
je 0x193bd
cmpl $0x13a, %ebp            # imm = 0x13A
jne 0x193a0
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x193a0
cmpl $0x2d, 0x1c(%rax)
jne 0x193a0
cmpq %r14, 0x38(%rax)
je 0x193a7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x48(%rbx), %rdi
callq 0x1467f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x193a2
jmp 0x193a0
movq 0x48(%rax), %rdi
callq 0x1467f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x193a2
jmp 0x19383
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rbx, %rbx
je 0x19411
cmpq %r14, 0x38(%rbx)
je 0x1940c
cmpl $0x1, (%rbx)
je 0x19411
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x193d3
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x19411
movq 0x48(%rbx), %rbx
jmp 0x193dd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1945b
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rax), %r15
leaq 0x16944(%rip), %rsi     # 0x2fd80
movq %r15, %rdi
callq 0x3180
testl %eax, %eax
je 0x19463
leaq 0x16929(%rip), %rsi     # 0x2fd78
movq %r15, %rdi
callq 0x3180
testl %eax, %eax
je 0x19473
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x192cc
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19480
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rbx, %rbx
je 0x19587
movl 0x1c(%rbx), %ecx
cmpl $0x28, %ecx
je 0x194b9
cmpl $0x2d, %ecx
jne 0x19587
cmpl $0x28, %ecx
jne 0x19587
cmpq %r14, 0x38(%rbx)
je 0x19587
movl 0x18(%rbx), %ebp
cmpl $0x150, %ebp            # imm = 0x150
jg 0x194e6
jne 0x19561
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x19480
movl %eax, %ecx
movl $0x0, %eax
testl %ecx, %ecx
jne 0x19502
jmp 0x19587
cmpl $0x151, %ebp            # imm = 0x151
jne 0x19508
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x19480
testl %eax, %eax
jne 0x19582
movq 0x48(%rbx), %rbx
jmp 0x1948a
cmpl $0x162, %ebp            # imm = 0x162
jne 0x1957e
cmpq $0x0, 0x40(%rbx)
jne 0x19527
movq 0x48(%rbx), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x19527
cmpq %r14, 0x38(%rax)
je 0x19582
cmpl $0x137, %ebp            # imm = 0x137
je 0x19569
cmpl $0x162, %ebp            # imm = 0x162
jne 0x1957e
cmpq $0x0, 0x40(%rbx)
jne 0x19561
movq 0x48(%rbx), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x19561
cmpl $0x13a, 0x18(%rax)      # imm = 0x13A
jne 0x19561
movq 0x40(%rax), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x19561
cmpq %r14, 0x38(%rcx)
je 0x195a2
cmpl $0x137, %ebp            # imm = 0x137
jne 0x1957e
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1957e
cmpl $0x2d, 0x1c(%rax)
jne 0x1957e
cmpq %r14, 0x38(%rax)
je 0x1958c
xorl %eax, %eax
jmp 0x19587
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x48(%rbx), %rdi
callq 0x1467f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x19587
jmp 0x1957e
movq 0x48(%rax), %rdi
callq 0x1467f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x19587
jmp 0x19561
// File: /workspace/github_c_makefile_star2_O1/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 0x1ec88(%rip), %rax     # 0x3824c
cmpl $0x0, (%rax)
jne 0x1963c
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x56870(%rip), %rax     # 0x6fe48
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x195f2
cmpq %r15, (%rax)
jne 0x195ec
cmpq %r14, 0x8(%rax)
je 0x19642
movq 0x18(%rax), %rax
jmp 0x195dc
movq 0x56867(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x19615
movq 0x18(%rax), %rcx
movq %rcx, 0x56857(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x1961f
movl $0x20, %edi
callq 0x61a1
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x56818(%rip), %rcx     # 0x6fe48
movq 0x30(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x30(%rcx)
popq %rbx
popq %r14
popq %r15
retq
orl %ebx, 0x10(%rax)
jmp 0x1963c