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

	for (g = graph; g; g = g->nxt)
	{	if (strcmp("_globals_", g->fctnm) == 0)
			continue;

		cnodes = cedges = 0;
		cfg_unvisit(g->all);
		cyclo_dfs(g->cfg);
		printf("%10s\t%6d nodes\t%6d edges\tcyclo %6d\n",
			g->fctnm, cnodes, cedges, cedges - cnodes + 2 +1);
		/* +1 for the return node, which doesn't appear separately */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x64b29(%rip), %rax     # 0x85fc8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2153e
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x23bf1(%rip), %rdi     # 0x450ad
callq 0x3160
cmpl $0x0, %eax
jne 0x214c8
jmp 0x2152d
movl $0x0, 0x64bb6(%rip)     # 0x86088
movl $0x0, 0x64bb0(%rip)     # 0x8608c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24520
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl 0x64b89(%rip), %edx     # 0x8608c
movl 0x64b7f(%rip), %ecx     # 0x86088
movl 0x64b78(%rip), %r8d     # 0x86088
subl 0x64b75(%rip), %r8d     # 0x8608c
addl $0x2, %r8d
addl $0x1, %r8d
leaq 0x23ee5(%rip), %rdi     # 0x4540b
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x214a3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_shared
static void
uno_shared(void)
{	SymRef *r;
	int stc;
	
	for (r = globuse; r; r = r->nxt)
	{	stc = r->status;

		if (Verbose
		|| (((stc&8) || (stc&32)) && (stc&4)))	/* imported + defined or aliased */

		if (!(stc&64) && ((stc&4) || !(stc&2)))
		{
			printf("%s:%d:\t%s\t\t%s",
			r->n->hdr.fnm, r->n->hdr.line, r->sm->nme->str,
			(stc&4)?"imported":"exported");

			if (stc&1) printf(" U"); else printf("  ");
			if (stc&8) printf(" D"); else printf("  ");
			if (stc&32) printf(" &"); else printf("  ");
			if (stc&128) printf(" [array]");
			printf("\n");
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x64681(%rip), %rax     # 0x85ff0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x21aee
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x2c9e9(%rip), %rax     # 0x4e378
cmpl $0x0, (%rax)
jne 0x219bd
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x219ae
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x21adb
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x21adb
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x21ad9
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x219e6
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x21ad9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movl -0xc(%rbp), %edi
andl $0x4, %edi
leaq 0x24115(%rip), %r8      # 0x45b2e
leaq 0x24105(%rip), %rax     # 0x45b25
cmpl $0x0, %edi
cmovneq %rax, %r8
leaq 0x240e9(%rip), %rdi     # 0x45b17
movb $0x0, %al
callq 0x30f0
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x21a50
leaq 0x240f0(%rip), %rdi     # 0x45b37
movb $0x0, %al
callq 0x30f0
jmp 0x21a5e
leaq 0x240e3(%rip), %rdi     # 0x45b3a
movb $0x0, %al
callq 0x30f0
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x21a79
leaq 0x240cd(%rip), %rdi     # 0x45b3d
movb $0x0, %al
callq 0x30f0
jmp 0x21a87
leaq 0x240ba(%rip), %rdi     # 0x45b3a
movb $0x0, %al
callq 0x30f0
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x21aa2
leaq 0x240a7(%rip), %rdi     # 0x45b40
movb $0x0, %al
callq 0x30f0
jmp 0x21ab0
leaq 0x24091(%rip), %rdi     # 0x45b3a
movb $0x0, %al
callq 0x30f0
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x21acb
leaq 0x2407f(%rip), %rdi     # 0x45b43
movb $0x0, %al
callq 0x30f0
leaq 0x22c6d(%rip), %rdi     # 0x4473f
movb $0x0, %al
callq 0x30f0
jmp 0x21adb
jmp 0x21add
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x21973
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_statistics
static void
uno_statistics(void)
{	Graphs *g;
	SymRef *r;
	int cnt;

	if (1 || Verbose || lintlike || debug)
		bound_stats();

	if (!Verbose) return;

	if (uno_prop) gen_stats();

	g = find_graph("main");

	if (!g)
		return;

	for (cnt=0, g = graph; g; g = g->nxt)
		if (g != glob_decls)
			cnt++;

	if (localonly)
	{	printf("uno: %3d function declarations\n", cnt);

		for (cnt = 0, r = globs; r; r = r->nxt)
			cnt++;
		printf("uno: %3d uninitialized global pointers\n", cnt);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x2bb90
leaq 0x2c374(%rip), %rax     # 0x4e378
cmpl $0x0, (%rax)
jne 0x2200e
jmp 0x220d6
cmpq $0x0, 0x63fea(%rip)     # 0x86000
je 0x2201d
callq 0x2f290
leaq 0x11fe0(%rip), %rdi     # 0x34004
callq 0x285b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22039
jmp 0x220d6
movl $0x0, -0x14(%rbp)
movq 0x63f81(%rip), %rax     # 0x85fc8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22078
movq -0x8(%rbp), %rax
cmpq 0x63f83(%rip), %rax     # 0x85fe0
je 0x22068
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2206a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2204b
leaq 0x2c31d(%rip), %rax     # 0x4e39c
cmpl $0x0, (%rax)
je 0x220d6
movl -0x14(%rbp), %esi
leaq 0x23c0b(%rip), %rdi     # 0x45c99
movb $0x0, %al
callq 0x30f0
movl $0x0, -0x14(%rbp)
movq 0x63f45(%rip), %rax     # 0x85fe8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x220c5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x220a7
movl -0x14(%rbp), %esi
leaq 0x23bea(%rip), %rdi     # 0x45cb9
movb $0x0, %al
callq 0x30f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_start
static void
nut_start(void)
{	Graphs *g;
	State *x;

	for (g = graph; g; g = g->nxt)
	{	if (g == glob_decls)
			continue;

		cfg_unvisit(g->all);
		fprintf(fd_uno, ": %s	%d\n", g->fctnm, g->status);	/* reminder of fct name */

		if (g->cfg == uno_prop)
		{	extern int err_path;
			err_path++;
			fct_details(fd_uno, uno_prop);
			err_path--;
		} else if (g->hasnuts)
		{	nut_setup(g);
			cfg_unvisit(g->all);
			x = g->cfg;
#if 1
			while (!x->n->hdr.nuts && x->direct && !x->direct->nxt)
				x = x->direct->branch;
#endif
			nut_hunt(fd_uno, x);
		}
		fprintf(fd_uno, "\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x63ed9(%rip), %rax     # 0x85fc8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22250
movq -0x8(%rbp), %rax
cmpq 0x63ed7(%rip), %rax     # 0x85fe0
jne 0x22110
jmp 0x2223f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq 0x63eec(%rip), %rdi     # 0x86010
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movswl 0x42(%rax), %ecx
leaq 0x23ba7(%rip), %rsi     # 0x45ce1
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0x63eb0(%rip), %rax     # 0x86000
jne 0x22194
leaq 0x74a87(%rip), %rax     # 0x96be0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x74a7b(%rip), %rax     # 0x96be0
movl %ecx, (%rax)
movq 0x63ea2(%rip), %rdi     # 0x86010
movq 0x63e8b(%rip), %rsi     # 0x86000
callq 0x28d50
leaq 0x74a5f(%rip), %rax     # 0x96be0
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x74a53(%rip), %rax     # 0x96be0
movl %ecx, (%rax)
jmp 0x2222a
movq -0x8(%rbp), %rax
cmpw $0x0, 0x44(%rax)
je 0x22228
movq -0x8(%rbp), %rdi
callq 0x28f50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x11(%rbp)
jne 0x221fd
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x58(%rcx)
movb %al, -0x11(%rbp)
je 0x221fd
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x22206
jmp 0x22218
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x221c5
movq 0x63df1(%rip), %rdi     # 0x86010
movq -0x10(%rbp), %rsi
callq 0x29000
jmp 0x2222a
movq 0x63ddf(%rip), %rdi     # 0x86010
leaq 0x22507(%rip), %rsi     # 0x4473f
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x220f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22316
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x22260
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x22370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x223c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x223c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x63d25(%rip), %rcx     # 0x86028
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x63d12(%rip)     # 0x86028
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2235a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x22320
movq 0x63c79(%rip), %rcx     # 0x85fc0
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x63c66(%rip)     # 0x85fc0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x223aa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x22370
movq 0x63ca1(%rip), %rcx     # 0x86038
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x63c8e(%rip)     # 0x86038
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22412
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x223c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x63c31(%rip), %rcx     # 0x86030
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x63c1e(%rip)     # 0x86030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: dup_graph
static void
dup_graph(Graphs *g, treenode *n)
{	int d, r;

	d = (strcmp(g->scope, "global") != 0);
	r = is_static_fct;

	fprintf(stderr, "uno: fct %s redefined\n", g->fctnm);
	fprintf(stderr, "\tdefined%sat %s:%d, redefined%sat %s:%d\n",
		d?" file-static ":" ",
		g->cfg->n->hdr.fnm, g->cfg->n->hdr.line,
		r?" file-static ":" ",
		n->hdr.fnm, n->hdr.line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x22cbb(%rip), %rsi     # 0x450fa
callq 0x3160
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl 0x63bf8(%rip), %eax     # 0x86050
movl %eax, -0x18(%rbp)
movq 0x2bb96(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x22cb9(%rip), %rsi     # 0x4512c
movb $0x0, %al
callq 0x3170
movq 0x2bb77(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movl -0x14(%rbp), %ecx
leaq 0x236ad(%rip), %rdx     # 0x45b3b
leaq 0x22cd7(%rip), %rax     # 0x4516c
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x10(%rax), %r8d
movl -0x18(%rbp), %esi
leaq 0x23677(%rip), %r9      # 0x45b3b
leaq 0x22ca1(%rip), %rax     # 0x4516c
cmpl $0x0, %esi
cmovneq %rax, %r9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r10
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
leaq 0x22c5b(%rip), %rsi     # 0x45143
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x3170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x63b14(%rip)     # 0x86028
je 0x22542
movq 0x63b0b(%rip), %rax     # 0x86028
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x63af8(%rip)     # 0x86028
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x3140
jmp 0x22550
movl $0x70, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: get_trans
static Trans *
get_trans(void)
{	Trans *t;

	if (freetrans)
	{	t = freetrans;
		freetrans = t->nxt;
		memset(t, 0, sizeof(Trans));
	} else
		t = (Trans *) emalloc(sizeof(Trans));
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x63000(%rip)     # 0x86030
je 0x2305e
movq 0x62ff7(%rip), %rax     # 0x86030
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x62fe4(%rip)     # 0x86030
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3140
jmp 0x2306c
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: mk_goto_node
static treenode *
mk_goto_node(leafnode *ident)
{	treenode *t;

	t = (treenode *) emalloc(sizeof(treenode));
	t->hdr.which = NODE_T;
	t->hdr.type = TN_JUMP;
	t->hdr.tok = GOTO;
	t->hdr.fnm = "UNO2";
	t->lnode = (treenode *) ident;

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x50, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rax
movl $0x1d, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x11c, 0x18(%rax)      # imm = 0x11C
movq -0x10(%rbp), %rax
leaq 0x220e9(%rip), %rcx     # 0x451ae
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x50, %edi
callq 0x54c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0x22, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x14e, 0x18(%rax)      # imm = 0x14E
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30c0
addq $0x9, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30c0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x2203d(%rip), %rsi     # 0x451b3
movb $0x0, %al
callq 0x3220
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: find_func_decl
static treenode *
find_func_decl(treenode *n)
{
	uno_assert((n != NULL), "no funcdef");

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

	/* must be a tn_pntr on lnode */

	return find_func_decl(n->rnode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2200e(%rip), %rsi     # 0x451de
callq 0x1fde0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x1c(%rax)
jne 0x231e9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x231fa
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x231b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x23400
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x62e31(%rip), %rcx     # 0x86068
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x62e1e(%rip)     # 0x86068
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x23400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x62dee(%rip), %rcx     # 0x86070
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x62ddb(%rip)     # 0x86070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x232c1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23309
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x21f14(%rip), %rsi     # 0x451e9
callq 0x1fde0
movq 0x62cc7(%rip), %rdi     # 0x85fa8
callq 0x22500
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_pop_start
static void
lts_pop_start(void)
{	Stack *f;

	uno_assert((sol != NULL), "start stack underflow");
	f = sol;
	sol = sol->nxt;

	f->nxt = fol;
	fol = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x62d38(%rip)     # 0x86068
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x21ebe(%rip), %rsi     # 0x451fd
callq 0x1fde0
movq 0x62d1d(%rip), %rax     # 0x86068
movq %rax, -0x8(%rbp)
movq 0x62d12(%rip), %rax     # 0x86068
movq 0x10(%rax), %rax
movq %rax, 0x62d07(%rip)     # 0x86068
movq 0x62ce0(%rip), %rcx     # 0x86048
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x62ccd(%rip)     # 0x86048
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_pop_end
static void
lts_pop_end(void)
{	Stack *f;

	uno_assert((eol != NULL), "end stack underflow");

	f = eol;
	eol = eol->nxt;

	f->nxt = fol;
	fol = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x62cd0(%rip)     # 0x86070
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x21e64(%rip), %rsi     # 0x45213
callq 0x1fde0
movq 0x62cb5(%rip), %rax     # 0x86070
movq %rax, -0x8(%rbp)
movq 0x62caa(%rip), %rax     # 0x86070
movq 0x10(%rax), %rax
movq %rax, 0x62c9f(%rip)     # 0x86070
movq 0x62c70(%rip), %rcx     # 0x86048
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x62c5d(%rip)     # 0x86048
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_new_stack
static Stack *
lts_new_stack(void)
{	Stack *f;

	if (!fol)
		return (Stack *) emalloc(sizeof(Stack));

	f = fol;
	fol = fol->nxt;
	f->nxt = (Stack *) 0;
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x62c38(%rip)     # 0x86048
jne 0x23422
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
jmp 0x23453
movq 0x62c1f(%rip), %rax     # 0x86048
movq %rax, -0x10(%rbp)
movq 0x62c14(%rip), %rax     # 0x86048
movq 0x10(%rax), %rax
movq %rax, 0x62c09(%rip)     # 0x86048
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x234ff
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x21d60(%rip), %rsi     # 0x4526e
callq 0x1fde0
cmpq $0x0, 0x62b25(%rip)     # 0x86040
je 0x23549
movq 0x62b1c(%rip), %rax     # 0x86040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x62b09(%rip)     # 0x86040
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3140
jmp 0x23557
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x62a36(%rip)     # 0x85fa8
je 0x23584
movq 0x62a2d(%rip), %rax     # 0x85fa8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x23591
leaq 0x21cfc(%rip), %rax     # 0x45287
movq %rax, -0x30(%rbp)
jmp 0x23591
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x62a48(%rip), %rcx     # 0x85ff8
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x62a35(%rip)     # 0x85ff8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x62a8c(%rip)     # 0x86070
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x21c9d(%rip), %rsi     # 0x45290
callq 0x1fde0
leaq 0x2ada5(%rip), %rax     # 0x4e3a4
cmpl $0x0, (%rax)
je 0x2367d
movq 0x62a65(%rip), %rax     # 0x86070
cmpl $0x0, 0x8(%rax)
jne 0x2367d
cmpq $0x0, 0x62a2f(%rip)     # 0x86048
je 0x2364a
movq 0x62a26(%rip), %rax     # 0x86048
movq %rax, -0x10(%rbp)
movq 0x62a1b(%rip), %rax     # 0x86048
movq 0x10(%rax), %rax
movq %rax, 0x62a10(%rip)     # 0x86048
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
jmp 0x23658
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x6299e(%rip), %rcx     # 0x86008
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x6298b(%rip)     # 0x86008
movq 0x629ec(%rip), %rax     # 0x86070
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: fct_retval
static void
fct_retval(treenode *n)
{
	if (!n->lnode)
	{	curgraph->status |= 2;	/* no return value */
		if (debug) printf("fct_retval %s adds 2\n", curgraph->fctnm);
	} else
		curgraph->status |= 1;	/* return value used */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2377c
movq 0x6285a(%rip), %rax     # 0x85fa8
movswl 0x42(%rax), %ecx
orl $0x2, %ecx
movw %cx, 0x42(%rax)
cmpl $0x0, 0x62870(%rip)     # 0x85fd0
je 0x2377a
movq 0x6283f(%rip), %rax     # 0x85fa8
movq (%rax), %rsi
leaq 0x21b53(%rip), %rdi     # 0x452c6
movb $0x0, %al
callq 0x30f0
jmp 0x2378e
movq 0x62825(%rip), %rax     # 0x85fa8
movswl 0x42(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x42(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_switch
static State *
lts_switch(State *now, treenode *node)
{	leafnode *ei;
	treenode *el, *en;
	int osaw;

	ei = mk_ident();	/* end of switch */
	el = mk_label_node(ei, node, "switch");
	en = mk_goto_node(ei);

	lts_push_end(en);	/* set break destination */

	if (!node->lnode)
		node->lnode = mk_int(1);

	/* lnode - switch expr
	 * rnode - cases
	 */
	lts_push_switch(now);	/* this is where jumps to case labels will go */
	now->n = node->lnode;	/* the switch expression */

	osaw = sawdefault;
	sawdefault = 0;

	now = lts_tree(now, node->rnode); /* process breaks and case labels */

	if (!sawdefault)	/* add nil jump to end */
	{	State *t, *stc;
		Trans *tr;

		want_break(node);

		stc = create_state(curgraph);
		stc->n = lts_top_end();		/* jump to endlabel */

		t = lts_top_switch(node);	/* add to switch stmnt */

		tr = get_trans();
		tr->branch = stc;
		tr->cond = mk_deflt();

		tr->nxt = t->succ;
		t->succ = tr;

		now = add_seq(now, stc->n);
	}

	sawdefault = osaw;

	now = lts_tree(now, el);	/* place end label */

	lts_pop_end();
	lts_pop_switch();
	return now;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x19dd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x21ad5(%rip), %rdx     # 0x4529d
callq 0x230e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23250
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x23807
movl $0x1, %edi
callq 0x19f10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x23dc0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0x62853(%rip), %eax     # 0x86078
movl %eax, -0x2c(%rbp)
movl $0x0, 0x62846(%rip)     # 0x86078
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x21040
movq %rax, -0x8(%rbp)
cmpl $0x0, 0x6282a(%rip)     # 0x86078
jne 0x238dd
movq -0x10(%rbp), %rdi
callq 0x235d0
movq 0x62744(%rip), %rdi     # 0x85fa8
callq 0x22500
movq %rax, -0x40(%rbp)
callq 0x236f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x23460
movq %rax, -0x38(%rbp)
callq 0x23020
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x19f60
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rsi
callq 0x232a0
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, 0x62792(%rip)     # 0x86078
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21040
movq %rax, -0x8(%rbp)
callq 0x23390
callq 0x23e10
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_push_switch
static void
lts_push_switch(State *stc)
{	SwStack *s;

	s = (SwStack *) emalloc(sizeof(SwStack));
	s->s = stc;
	s->nxt = swol;
	swol = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x62294(%rip), %rcx     # 0x86080
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x62281(%rip)     # 0x86080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x23ec0
movq -0x10(%rbp), %rax
cmpl $0x140, 0x18(%rax)      # imm = 0x140
jne 0x23ec0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x23e50
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x23eb0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x23e50
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x23f7c
movq -0x10(%rbp), %rax
cmpl $0x3, 0x1c(%rax)
jne 0x23f75
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x23f75
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x23f55
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x22(%rbp)
je 0x23f11
movq -0x20(%rbp), %rax
cmpl $0xa, 0x1c(%rax)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x23f1a
jmp 0x23f28
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x23ef7
cmpq $0x0, -0x20(%rbp)
je 0x23f53
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x23f53
movq -0x20(%rbp), %rax
cmpl $0x30, 0x1c(%rax)
jne 0x23f53
movl $0x1, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x23f55
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x24180
movl %eax, -0x4(%rbp)
jmp 0x23f7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: no_return
static int
no_return(char *s, int has_arg, int with_arg)
{	EX *nx;

	for (nx = exs; nx; nx = nx->nxt)
		if (strcmp(nx->f, s) == 0
		&&  (nx->has_arg == 0
		||   (has_arg && nx->arg_val == with_arg)))
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x61e1f(%rip), %rax     # 0x85fb8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x241ee
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x241de
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x241d5
cmpl $0x0, -0x14(%rbp)
je 0x241de
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x241de
movl $0x1, -0x4(%rbp)
jmp 0x241f5
jmp 0x241e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2419d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2114b(%rip), %rsi     # 0x4536b
callq 0x1fde0
movq 0x61dcc(%rip), %rax     # 0x85ff8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24276
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x24266
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x61d55(%rip), %rcx     # 0x85fa8
cmpq (%rcx), %rax
jne 0x24266
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2429d
jmp 0x24268
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24230
movq 0x29d7b(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x210fb(%rip), %rsi     # 0x45386
movb $0x0, %al
callq 0x3170
movq 0x61dbf(%rip), %rax     # 0x86058
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: cfg_unvisit
static void
cfg_unvisit(State *t)
{	State *s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x242fb
movq -0x10(%rbp), %rax
movw $0x0, 0x4a(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20300
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x242c4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x24552
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24552
movq -0x8(%rbp), %rax
movswl 0x4a(%rax), %eax
cmpl $0x0, %eax
je 0x24557
jmp 0x2461f
movq -0x8(%rbp), %rax
movw $0x1, 0x4a(%rax)
movl 0x61b25(%rip), %eax     # 0x8608c
addl $0x1, %eax
movl %eax, 0x61b1c(%rip)     # 0x8608c
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x24597
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x245a0
jmp 0x2461f
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x61ace(%rip), %eax     # 0x86088
addl $0x1, %eax
movl %eax, 0x61ac5(%rip)     # 0x86088
movq -0x8(%rbp), %rax
movswl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x245e9
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x245e9
movl 0x61aa8(%rip), %eax     # 0x86088
addl $-0x1, %eax
movl %eax, 0x61a9f(%rip)     # 0x86088
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1d, 0x1c(%rax)
jne 0x24605
movl 0x61a8c(%rip), %eax     # 0x86088
addl $0x1, %eax
movl %eax, 0x61a83(%rip)     # 0x86088
movq -0x10(%rbp), %rdi
callq 0x24520
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2457c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: gen_graph
static void
gen_graph(Graphs *g)
{
	if (!g || g->visited) return;
	g->visited = 1;

	curgraph = g;

	dfs_uno(g->cfg);		/* collect info */

	if (!uno_prop) ana_locs(g);	/* check for unreferenced locals */

	uno_assert((dfstack == NULL), "internal error, dfstack non-zero");

	if (uno_p == 4)	/* -U3 or -local */
	{	if (!localonly)
			uno_snapshot(g);	/* write the .uno file */
		if (!uno_prop)
		{	cfg_unvisit(g->all);
			if (debug) printf("\n============\n");
			dfs_bound(g->cfg, ZT, ZT, ZS);	/* check for array indexing errors */
	}	}

	if (uno_prop && g->cfg != uno_prop)
	{	cfg_unvisit(g->all);
		dfs_generic(g->cfg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x24bb0
movq -0x8(%rbp), %rax
movswl 0x40(%rax), %eax
cmpl $0x0, %eax
je 0x24bb5
jmp 0x24ca3
movq -0x8(%rbp), %rax
movw $0x1, 0x40(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x613de(%rip)     # 0x85fa8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24630
cmpq $0x0, 0x61421(%rip)     # 0x86000
jne 0x24bea
movq -0x8(%rbp), %rdi
callq 0x28620
cmpq $0x0, 0x6149e(%rip)     # 0x86090
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x20e13(%rip), %rsi     # 0x45a14
callq 0x1fde0
leaq 0x29533(%rip), %rax     # 0x4e140
cmpl $0x4, (%rax)
jne 0x24c6e
leaq 0x29783(%rip), %rax     # 0x4e39c
cmpl $0x0, (%rax)
jne 0x24c27
movq -0x8(%rbp), %rdi
callq 0x28890
cmpq $0x0, 0x613d1(%rip)     # 0x86000
jne 0x24c6c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
cmpl $0x0, 0x6138b(%rip)     # 0x85fd0
je 0x24c55
leaq 0x20de7(%rip), %rdi     # 0x45a35
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2c690
jmp 0x24c6e
cmpq $0x0, 0x6138a(%rip)     # 0x86000
je 0x24ca3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0x61379(%rip), %rax     # 0x86000
je 0x24ca3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30020
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_report0
static void
uno_report0(FILE *fd, char *s, int t, SymRef *d)
{	SymRef *r;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x24d35
cmpl $-0x1, -0x14(%rbp)
je 0x24ce8
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x24d25
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %r9d
leaq 0x10098(%rip), %rsi     # 0x34db6
movb $0x0, %al
callq 0x3170
jmp 0x24d27
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24ccf
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_indirect_calls
static void
uno_indirect_calls(FILE *fd)
{	Gst *k, *m;
	/* for each fct in grst, add all entries of frst */
	/* assumes that any fct that can call another fct through a ptr,
	   can in principle call any of the fcts that are passed around
	   with fct ptrs */

	for (k = grst; k; k = k->nxt)
	for (m = frst; m; m = m->nxt)
		fprintf(fd, "p\t%s\t%s\t%d\n",
			k->gnm->fctnm, m->gnm->fctnm, m->gnm->status);

	/* separately also list all fcts that could be called indirectly */
	for (m = frst; m; m = m->nxt)
		fprintf(fd, "q\t%s\t%s\t%d\n",
			m->gnm->fctnm, "indirect", m->gnm->status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x61365(%rip), %rax     # 0x860b8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24dc0
movq 0x61363(%rip), %rax     # 0x860c8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24db0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movswl 0x42(%rax), %r8d
leaq 0x20d5b(%rip), %rsi     # 0x45af6
movb $0x0, %al
callq 0x3170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24d69
jmp 0x24db2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x24d57
movq 0x61301(%rip), %rax     # 0x860c8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24e0f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movswl 0x42(%rax), %r8d
leaq 0x20d0f(%rip), %rsi     # 0x45b02
leaq 0x20d14(%rip), %rcx     # 0x45b0e
movb $0x0, %al
callq 0x3170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24dcb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: newpathcond
static void
newpathcond(treenode *exp, treenode *val)
{	PathCond *np;

	if (debug) printf("New Pathcondition <%s>\n", x_stmnt(exp));

	np = getpathframe();
	np->exp = exp;
	np->val = val;
	np->nxt = pathcond;
	pathcond = np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x60d99(%rip)     # 0x85fd0
je 0x25253
movq -0x8(%rbp), %rdi
callq 0x4ec0
movq %rax, %rsi
leaq 0x2077b(%rip), %rdi     # 0x459c7
movb $0x0, %al
callq 0x30f0
callq 0x25450
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x60e1e(%rip), %rcx     # 0x86098
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x60e0b(%rip)     # 0x86098
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: setknownzeros
static void
setknownzeros(treenode *n, Trans *t, PathCond *np)
{	DefUse *d;
	SymList *s;
	SymRef *r;

	if (!n) return;

	if (n->hdr.type == TN_IF)
		d = ((if_node *)n)->cond->hdr.defuse;
	else
		d = n->hdr.defuse;

	if (d)
	for (s = d->other; s; s = s->nxt)
		if (s->sm->decl_level < FUNCTION_SCOPE	/* global */
		&&  (s->mark & USE))
			if (simple_form(s->sm, np))
			{	/* s known nonzero */
				r = uno_getref(s->sm);
				r->nxt = t->knz;
				t->knz = r;
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x252c0
jmp 0x2537d
movq -0x8(%rbp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x252dc
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x252e8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2537d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2537b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movswl 0x20(%rax), %eax
cmpl $0x3, %eax
jge 0x2536b
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2536b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x27cb0
cmpl $0x0, %eax
je 0x25369
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20420
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2536b
jmp 0x2536d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x252ff
jmp 0x2537d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: dumknow
static void
dumknow(treenode *n, Trans *t)
{	SymRef *r;

	printf("KnownNonZero @ %s:%d: ",
		n?n->hdr.fnm:"--",
		n?n->hdr.line:0);
	for (r = t->knz; r; r = r->nxt)
		printf("%s, ", r->sm->nme->str);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x253b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x253c2
leaq 0xfe4f(%rip), %rax      # 0x3520b
movq %rax, -0x20(%rbp)
jmp 0x253c2
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x253dd
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x253e4
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x253e4
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x205ed(%rip), %rdi     # 0x459df
movb $0x0, %al
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25437
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x205d4(%rip), %rdi     # 0x459f6
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x25405
leaq 0x1f301(%rip), %rdi     # 0x4473f
movb $0x0, %al
callq 0x30f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: getpathframe
static PathCond *
getpathframe(void)
{	PathCond *np;

	if (pathfree)
	{	np = pathfree;
		pathfree = pathfree->nxt;
	} else
		np = (PathCond *) emalloc(sizeof(PathCond));

	return np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x60c40(%rip)     # 0x860a0
je 0x25481
movq 0x60c37(%rip), %rax     # 0x860a0
movq %rax, -0x8(%rbp)
movq 0x60c2c(%rip), %rax     # 0x860a0
movq 0x10(%rax), %rax
movq %rax, 0x60c21(%rip)     # 0x860a0
jmp 0x2548f
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)