LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/tree.c
// Function: find_func_name
leafnode *
find_func_name(treenode *n)
{
	while (n && (n->hdr.which != LEAF_T))
	{	switch(n->hdr.which) {
		case NODE_T:
			switch(n->hdr.type) {
			case TN_DECL:
				n = n->rnode;
				break;
			case TN_FUNC_DECL:
				n = n->lnode;
				break;
			case TN_ARRAY_DECL:
				fprintf(stderr,
					"%s: error: unexpected node in find_func_name;\n"
					"\tnode: %s, type: %s (%s:%d)\n", progname,
						name_of_nodetype(n->hdr.which),
						name_of_node(n->hdr.type),
						n->hdr.fnm, n->hdr.line);
				n = n->rnode;	/* 1/4/10: a guess */
				break;
			default:
				goto bad;
			}
			break;
		case FOR_T:
			if (n->hdr.type == TN_FUNC_DEF)
				n = ((for_node *) n)->test;
			break;
		default:
bad:			fprintf(stderr,
				"%s: error: bad node in find_func_name;\n"
				"	node: %s, type: %s\n",
				progname, name_of_nodetype(n->hdr.which),
				name_of_node(n->hdr.type));
			n = NULL;
			break;
	}	}

	return (leafnode*) n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x87d5
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x87e1
jmp 0x893d
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x3, %eax
je 0x88c2
jmp 0x87f5
movl -0x10(%rbp), %eax
subl $0x4, %eax
jne 0x88da
jmp 0x8803
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x883c
jmp 0x8814
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x882b
jmp 0x881e
movl -0x14(%rbp), %eax
subl $0x6, %eax
je 0x884a
jmp 0x88be
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88c0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88c0
movq 0x457a7(%rip), %rax     # 0x4dff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x458f9(%rip), %rax     # 0x4e158
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7ff0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x8270
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rax, %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
leaq 0x2ce91(%rip), %rsi     # 0x35737
movl %eax, (%rsp)
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88c0
jmp 0x88dc
jmp 0x8938
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x88d8
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8938
jmp 0x88dc
movq 0x45715(%rip), %rax     # 0x4dff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
leaq 0x45867(%rip), %rax     # 0x4e158
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7ff0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x8270
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rax, %r8
leaq 0x2ce59(%rip), %rsi     # 0x35782
movb $0x0, %al
callq 0x3170
movq $0x0, -0x8(%rbp)
jmp 0x87bc
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/treestk.c
// Function: new_stk_item
Stk_Item  *
new_stk_item( FILE *fp, char *fname )
{
    Stk_Item *stk_item;

	if (freestk)
	{	stk_item = freestk;
		freestk = freestk->next;
		memset(stk_item, 0, STK_ITEM_SZE);
	} else
		stk_item = emalloc(STK_ITEM_SZE);

    stk_item->filename = emalloc(strlen(fname)+1);
    strcpy(stk_item->filename, fname);

    if ((stk_item->yybuff = yy_create_buffer(fp, YYBUFF_SIZE )) == NULL){
        efree(stk_item->filename);
        efree(stk_item);
        return((Stk_Item *) NULL);
    }

    if ((stk_item->node_heap  = CreateHeap(MX_NODE_SZE, 0)) == NULL){
        efree(stk_item->filename);
        yy_delete_buffer( stk_item->yybuff );
        efree(stk_item);
        return((Stk_Item *) NULL);
    }

    stk_item->yyin     = fp;

    stk_item->yylineno = 1;
    stk_item->yycolno  = 0;
    stk_item->yynxtcol = 0;

    stk_item->parse_tree = (treenode *) NULL;

    stk_item->next = (Stk_Item *) NULL;

    return(stk_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x47748(%rip)     # 0x50460
je 0x8d49
movq 0x4773f(%rip), %rax     # 0x50460
movq %rax, -0x20(%rbp)
movq 0x47734(%rip), %rax     # 0x50460
movq 0x38(%rax), %rax
movq %rax, 0x47729(%rip)     # 0x50460
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3140
jmp 0x8d57
movl $0x40, %edi
callq 0x54c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3080
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x13fe0
movq -0x20(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x8dc7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x54b0
movq -0x20(%rbp), %rdi
callq 0x54b0
movq $0x0, -0x8(%rbp)
jmp 0x8e5a
movl $0x60, %edi
xorl %esi, %esi
callq 0x4ee0
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x8e0e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x54b0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x14db0
movq -0x20(%rbp), %rdi
callq 0x54b0
movq $0x0, -0x8(%rbp)
jmp 0x8e5a
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%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/treestk.c
// Function: delete_stk_item
void
delete_stk_item(Stk_Item *stk_item)
{
	if (!stk_item)
		return;
#ifdef PC
	if (stk_item->yybuff)
		yy_delete_buffer(stk_item->yybuff);
#endif
	if (stk_item->node_heap)
	{	DestroyHeap(stk_item->node_heap);
		memset(stk_item, 0, sizeof(Stk_Item));
	}

	stk_item->next = freestk;
	freestk = stk_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8e85
jmp 0x8ec7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8ead
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5020
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3140
movq 0x475ac(%rip), %rcx     # 0x50460
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x47599(%rip)     # 0x50460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/treestk.c
// Function: tree_parse
int
tree_parse(TreeStack *treestk, int parse_all)
{
    int cnt = 0;

    if (is_empty(treestk))
        return(0);

    do {
	yyparse();	/* returns 1 on error 0 on accept */
        cnt++;
        get_next_file(treestk);

        if (is_empty(treestk))
            break;

    } while (parse_all);

    return(cnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8fe0
cmpl $0x0, %eax
je 0x911d
movl $0x0, -0x4(%rbp)
jmp 0x9154
jmp 0x911f
callq 0x156f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9160
movq -0x10(%rbp), %rdi
callq 0x8fe0
cmpl $0x0, %eax
je 0x9146
jmp 0x914e
jmp 0x9148
cmpl $0x0, -0x14(%rbp)
jne 0x911f
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/lexer.c
// Function: yy_get_previous_state
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);
	yy_current_state += YY_AT_BOL();

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		if ( yy_accept[yy_current_state] )
			{
			(yy_last_accepting_state) = yy_current_state;
			(yy_last_accepting_cpos) = yy_cp;
			}
		if ( *yy_cp )
			{
			YY_CHAR yy_c = YY_SC_TO_UI(*yy_cp);
			if ( yy_accept[yy_current_state] )
				{
				(yy_last_accepting_state) = yy_current_state;
				(yy_last_accepting_cpos) = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			}
		else
			yy_current_state = yy_NUL_trans[yy_current_state];
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3bfd2(%rip), %eax     # 0x5048c
movl %eax, -0x4(%rbp)
movq 0x3bfcc(%rip), %rax     # 0x50490
movq 0x3bfcd(%rip), %rcx     # 0x50498
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x3bfd9(%rip), %rax     # 0x504b8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x3bfb2(%rip), %rax     # 0x504a0
jae 0x145e0
movslq -0x4(%rbp), %rcx
leaq 0x21981(%rip), %rax     # 0x35e80
cmpw $0x0, (%rax,%rcx,2)
je 0x1451a
movl -0x4(%rbp), %eax
movl %eax, 0x3bf9d(%rip)     # 0x504ac
movq -0x10(%rbp), %rax
movq %rax, 0x3bf96(%rip)     # 0x504b0
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x145bc
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21945(%rip), %rax     # 0x35e80
cmpw $0x0, (%rax,%rcx,2)
je 0x14556
movl -0x4(%rbp), %eax
movl %eax, 0x3bf61(%rip)     # 0x504ac
movq -0x10(%rbp), %rax
movq %rax, 0x3bf5a(%rip)     # 0x504b0
jmp 0x14558
movslq -0x4(%rbp), %rcx
leaq 0x2668d(%rip), %rax     # 0x3abf0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x21d99(%rip), %rax     # 0x36310
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x14594
movslq -0x4(%rbp), %rcx
leaq 0x26b35(%rip), %rax     # 0x3b0c0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x14558
movslq -0x4(%rbp), %rcx
leaq 0x26651(%rip), %rax     # 0x3abf0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x26fdd(%rip), %rax     # 0x3b590
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x145cd
movslq -0x4(%rbp), %rcx
leaq 0x2b8a9(%rip), %rax     # 0x3fe70
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x145cf
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x144e3
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/lexer.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    
	yy_current_state = yy_NUL_trans[yy_current_state];
	yy_is_jam = (yy_current_state == 0);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2b86e(%rip), %rax     # 0x3fe70
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x14624
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x1462a
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: dep_node
DuG *
dep_node(SymList *a, int imark)
{	DuG *g;

	for (g = d_g; g; g = g->nxt)
		if (g->sm == a->sm)
		{	g->marks |= imark;
			goto done;
		}

	g = (DuG *) emalloc(sizeof(DuG));

	if (!a->sm) printf("%s: dep_node without symbol\n", progname);

	g->sm = a->sm;
	g->marks = imark;
	g->rdcls |= RealDecls;
	g->d_e = (DuGP *) 0;
	g->nxt = d_g;
	d_g = g;
done:
	return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x3a7fa(%rip), %rax     # 0x54d20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a564
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1a554
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x1a5e4
jmp 0x1a556
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1a52a
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a595
leaq 0x33bd4(%rip), %rax     # 0x4e158
movq (%rax), %rsi
leaq 0x2a090(%rip), %rdi     # 0x4461e
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x3a774(%rip), %ecx     # 0x54d28
movq -0x18(%rbp), %rax
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x3a74f(%rip), %rcx     # 0x54d20
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3a73c(%rip)     # 0x54d20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: rel_all
void
rel_all(SymList *s)
{
	if (!s) return;

	rel_all(s->all);
	s->all = freesyml;
	freesyml = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1aee5
jmp 0x1af0c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1aed0
movq 0x39e37(%rip), %rcx     # 0x54d30
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x39e24(%rip)     # 0x54d30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: symadd
SymList *
symadd(symentry_t *sm, int mark)
{	SymList *sl;

	if (freesyml)
	{	sl = freesyml;
		freesyml = freesyml->all;
		memset(sl, 0, sizeof(SymList));
	} else
		sl = (SymList *) emalloc(sizeof(SymList));

	sl->nxt = (SymList *) 0;
	sl->mark = mark;
	sl->sm  = sm;

	sl->all = allsym;
	allsym = sl;

	return sl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x39dd9(%rip)     # 0x54d30
je 0x1af88
movq 0x39dd0(%rip), %rax     # 0x54d30
movq %rax, -0x18(%rbp)
movq 0x39dc5(%rip), %rax     # 0x54d30
movq 0x18(%rax), %rax
movq %rax, 0x39dba(%rip)     # 0x54d30
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3140
jmp 0x1af96
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x39d79(%rip), %rcx     # 0x54d38
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x39d66(%rip)     # 0x54d38
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: set_fbase
void
set_fbase(int ln, char *s)
{	Fbase *f;

	fbase = (Fbase *) 0;

	f = (Fbase *) emalloc(sizeof(Fbase));
	f->nm = (char *) emalloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->ln = ln;
	f->fcalls = (Fbase *) 0;
	f->nxt = fbase;
	fbase = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, 0x39d46(%rip) # 0x54d40
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3080
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x39cec(%rip), %rcx     # 0x54d40
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x39cd9(%rip)     # 0x54d40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: add_fbase
static void
add_fbase(int ln, char *s)
{	Fbase *f, *g;

	if (!vis_p) return;

	if (!fbase)
		set_fbase(0, want);

	f = (Fbase *) emalloc(sizeof(Fbase));
	f->nm = (char *) emalloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->ln = ln;
	f->nxt = f->fcalls = (Fbase *) 0;

	for (g = fbase->fcalls; g; g = g->fcalls)
		if (strcmp(g->nm, s) == 0)	/* follows a match */
		{	f->fcalls = g->fcalls;
			g->fcalls = f;
			return;
		}

	f->fcalls = fbase->fcalls;	/* or at the front */
	fbase->fcalls = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x351fa(%rip), %rax     # 0x50420
cmpl $0x0, (%rax)
jne 0x1b230
jmp 0x1b325
cmpq $0x0, 0x39b08(%rip)     # 0x54d40
jne 0x1b24b
leaq 0x32f07(%rip), %rax     # 0x4e148
movq (%rax), %rsi
xorl %edi, %edi
callq 0x1afe0
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3080
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq 0x39a8f(%rip), %rax     # 0x54d40
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b303
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x1b2f3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1b325
jmp 0x1b2f5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1b2b9
movq 0x39a36(%rip), %rax     # 0x54d40
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq 0x39a1f(%rip), %rax     # 0x54d40
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: check_compound
void
check_compound(treenode *p, treenode *n)
{
	if (n
	&&  n->hdr.which == NODE_T
	&&  n->hdr.type == TN_STEMNT) /* instead of TN_BLOCK */
	{
	if (0)	printf("uno: %s:%d: missing compound\n", p->hdr.fnm, p->hdr.line);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b638
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x1b638
movq -0x10(%rbp), %rax
cmpl $0x23, 0x1c(%rax)
jne 0x1b638
jmp 0x1b638
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: add_aio
static void
add_aio(DefUse *d, treenode *n)
{	ArList *nio;

	if (!d)
	{	if (0 && !exclude_location(n))
			printf("uno: %s:%d aio without d to attach to\n",
			n->hdr.fnm, n->hdr.line);
		return;
	}
	for (nio = d->aio; nio; nio = nio->nxt)
		if (nio->tn == n)
			return;

	nio = get_arlist();
	nio->tn = n;
	nio->nxt = d->aio;
	d->aio = nio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1da59
jmp 0x1dabb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1da8b
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1da7b
jmp 0x1dabb
jmp 0x1da7d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1da65
callq 0x1de40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: cache_str
static char *
cache_str(char *s)
{	Cached *c;
	for (c = cst; c; c = c->nxt)
	{	if (strcmp(c->nm, s) == 0)
		{	return c->nm;
	}	}
	c = (Cached *) emalloc(sizeof(Cached));
	c->nm = (char *) emalloc(strlen(s)+1);
	strcpy(c->nm, s);
	c->nxt = cst;
	cst = c;
	return c->nm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x58a8d(%rip), %rax     # 0x76570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1db20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x1db10
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1db82
jmp 0x1db12
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1dae7
movl $0x10, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3080
movq 0x58a0c(%rip), %rcx     # 0x76570
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x589f9(%rip)     # 0x76570
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: merge_syms
static SymList *
merge_syms(SymList *s1, SymList *s2)
{	SymList *s, *t, *ns;
	SymList *add_to_s1 = (SymList *) 0;
	SymList *last_in   = (SymList *) 0;

	/* static int mcnt=1; */

	if (!s1) return s2;
	if (!s2) return s1;

	for (t = s2; t; t = t->nxt)
	{	for (s = s1; s; s = s->nxt)
			if (s->sm == t->sm
			&&  s->mark == t->mark)
				break;

		if (!s) /* add t */
		{	ns = symadd(t->sm, t->mark);
			/* preserve relative order */
			if (!last_in)
				add_to_s1 = last_in = ns;
			else
			{	last_in->nxt = ns;
				last_in = ns;
			}
	}	}

	if (!last_in)
		return s1;
	last_in->nxt = s1;
	s1 = add_to_s1;
	return s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1dc14
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dd08
cmpq $0x0, -0x18(%rbp)
jne 0x1dc28
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dd08
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1dcdb
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1dc7e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1dc6e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x1dc6e
jmp 0x1dc7e
jmp 0x1dc70
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1dc43
cmpq $0x0, -0x20(%rbp)
jne 0x1dcc8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1af40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x1dcb2
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x1dcc6
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1dcc8
jmp 0x1dcca
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1dc30
cmpq $0x0, -0x40(%rbp)
jne 0x1dcec
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dd08
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/dflow.c
// Function: merge_aio
static ArList *
merge_aio(ArList *a1, ArList *a2)
{	ArList *s, *t, *ns;
	ArList *add_to_a1 = (ArList *) 0;
	ArList *last_in   = (ArList *) 0;

	if (!a1) return a2;
	if (!a2) return a1;

	for (t = a2; t; t = t->nxt)
	{	for (s = a1; s; s = s->nxt)
			if (s->tn == t->tn)
				break;

		if (!s) /* add t */
		{	ns = get_arlist();
			ns->tn = t->tn;
			if (!last_in)	/* preserve relative order */
				add_to_a1 = last_in = ns;
			else
			{	last_in->nxt = ns;
				last_in = ns;
	}	}	}

	if (!last_in)
		return a1;
	last_in->nxt = a1;
	a1 = add_to_a1;
	return a1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1dd54
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de35
cmpq $0x0, -0x18(%rbp)
jne 0x1dd68
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de35
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1de08
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ddac
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1dd9c
jmp 0x1ddac
jmp 0x1dd9e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1dd83
cmpq $0x0, -0x20(%rbp)
jne 0x1ddf5
callq 0x1de40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x40(%rbp)
jne 0x1dddf
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x1ddf3
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1ddf5
jmp 0x1ddf7
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1dd70
cmpq $0x0, -0x40(%rbp)
jne 0x1de19
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de35
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/prnttree.c
// Function: print_recur
void
print_recur(treenode *root, FILE *fp)
{
	can_flush = fp;
	strcpy(PBuf, "");
	do_recur(root, 0);
	if (!viewtree) fprintf(fp, "%s", PBuf);
	can_flush = (FILE *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x66665(%rip)     # 0x85f80
leaq 0x56c5e(%rip), %rdi     # 0x76580
leaq 0x1548c(%rip), %rsi     # 0x34db5
callq 0x3080
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1e050
leaq 0x2ea48(%rip), %rax     # 0x4e388
cmpl $0x0, (%rax)
jne 0x1f95e
movq -0x10(%rbp), %rdi
leaq 0x261d2(%rip), %rsi     # 0x45b22
leaq 0x56c29(%rip), %rdx     # 0x76580
movb $0x0, %al
callq 0x3170
movq $0x0, 0x66617(%rip) # 0x85f80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: find_suppress_lines
void
find_suppress_lines(char *fn)
{	FILE	*fd;
	char	buf[1024];
	int	cnt = 0;
	ST	*nst;

	if ((fd = fopen(fn, "r")) == NULL)
	{	return;
	}

	while (fgets(buf, sizeof(buf), fd) != NULL)
	{	cnt++;
		if (strstr(buf, "@uno_suppress") != NULL)
		{	nst = (ST *) emalloc(sizeof(ST));
			nst->name = (char *) emalloc(strlen(fn)+1);
			strcpy(nst->name, fn);
			nst->line = cnt;
			nst->nxt = st;
			st = nst;
	}	}

	fclose(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl $0x0, -0x414(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x251db(%rip), %rsi     # 0x44c0f
callq 0x31f0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1fa48
jmp 0x1fb15
jmp 0x1fa4a
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x3150
cmpq $0x0, %rax
je 0x1fb0c
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0x254ba(%rip), %rsi     # 0x44f40
callq 0x3240
cmpq $0x0, %rax
je 0x1fb07
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x420(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x420(%rbp), %rax
movq %rcx, (%rax)
movq -0x420(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3080
movl -0x414(%rbp), %ecx
movq -0x420(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x664b2(%rip), %rcx     # 0x85fa0
movq -0x420(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x420(%rbp), %rax
movq %rax, 0x66499(%rip)     # 0x85fa0
jmp 0x1fa4a
movq -0x10(%rbp), %rdi
callq 0x30b0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: read_suppress
void
read_suppress(void)
{	FILE *fd;

	if ((fd = fopen("uno_suppress", "r")) != NULL)
	{	get_suppressors(fd);
		fclose(fd);
	}

	if (working_dir != NULL)
	{	char *efn;

		efn = emalloc(strlen(working_dir)+strlen("/uno_suppress")+1);
		sprintf(efn, "%s/uno_suppress", working_dir);

		if ((fd = fopen(efn, "r")) != NULL)
		{	get_suppressors(fd);
			fclose(fd);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x25422(%rip), %rdi     # 0x44f51
leaq 0x250d9(%rip), %rsi     # 0x44c0f
callq 0x31f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1fb57
movq -0x8(%rbp), %rdi
callq 0x1fbe0
movq -0x8(%rbp), %rdi
callq 0x30b0
leaq 0x2e7ca(%rip), %rax     # 0x4e328
cmpq $0x0, (%rax)
je 0x1fbd1
leaq 0x2e7bd(%rip), %rax     # 0x4e328
movq (%rax), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0xd, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2e796(%rip), %rax     # 0x4e328
movq (%rax), %rdx
leaq 0x253b2(%rip), %rsi     # 0x44f4e
movb $0x0, %al
callq 0x3220
movq -0x10(%rbp), %rdi
leaq 0x25061(%rip), %rsi     # 0x44c0f
callq 0x31f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1fbcf
movq -0x8(%rbp), %rdi
callq 0x1fbe0
movq -0x8(%rbp), %rdi
callq 0x30b0
jmp 0x1fbd1
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: get_suppressors
static void
get_suppressors(FILE *fd)
{	char *p, buf[1024];
	ST *nst;

	while (fgets(buf, sizeof(buf), fd))
	{	if ((p = strchr(buf, '\t')) == NULL)
		{	fprintf(stderr, "uno: suppress file format <%s>\n", buf);
		} else
		{	*p++ = '\0';
			nst = (ST *) emalloc(sizeof(ST));
			nst->name = (char *) emalloc(strlen(buf)+1);
			strcpy(nst->name, buf);
			if (!isdigit((int) *p))
			{	nst->line = 0;	/* meaning all lines */
			} else
			{	nst->line = atoi(p);
			}
			nst->nxt = st;
			st = nst;
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x3150
cmpq $0x0, %rax
je 0x1fd15
leaq -0x410(%rbp), %rdi
movl $0x9, %esi
callq 0x30e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1fc4d
movq 0x2e3c8(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq -0x410(%rbp), %rdx
leaq 0x25476(%rip), %rsi     # 0x450b7
movb $0x0, %al
callq 0x3170
jmp 0x1fd10
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x418(%rbp), %rax
movq %rcx, (%rax)
movq -0x418(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0x3080
callq 0x3250
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1fcdb
movq -0x418(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x1fcf0
movq -0x10(%rbp), %rdi
callq 0x3200
movl %eax, %ecx
movq -0x418(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x662a9(%rip), %rcx     # 0x85fa0
movq -0x418(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x418(%rbp), %rax
movq %rax, 0x66290(%rip)     # 0x85fa0
jmp 0x1fbef
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: suppress
int
suppress(char *fn, int ln)
{	ST *nst;

	for (nst = st; nst; nst = nst->nxt)
		if ((nst->line == 0 || nst->line == ln)
		&& (strcmp(nst->name, fn) == 0
		|| (strncmp(fn, "./", 2) == 0 && strcmp(nst->name, fn+2) == 0)))
		{
#if 0
			if (!nst->reported)
			fprintf(stderr, "uno: %s:%d: suppressing error report\n", fn, ln);
#endif
			nst->reported++;
			return 1;
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x6626a(%rip), %rax     # 0x85fa0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1fdcc
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x1fd5b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1fdb9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
je 0x1fda3
movq -0x10(%rbp), %rdi
leaq 0x251e3(%rip), %rsi     # 0x44f5e
movl $0x2, %edx
callq 0x3070
cmpl $0x0, %eax
jne 0x1fdb9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x1fdb9
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1fdd3
jmp 0x1fdbb
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1fd3a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: rev_release
SymRef *
rev_release(SymRef *r)	/* release a list of symrefs */
{
	if (r)
	{	rev_release(r->nxt);
		r->nxt = dfs_free;
		dfs_free = r;
	}
	return (SymRef *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2033a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x20300
movq 0x65c89(%rip), %rcx     # 0x85fb0
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x65c76(%rip)     # 0x85fb0
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: custom_exit
void
custom_exit(const char *s)
{	EX *nx;
	char *col;

	col = strchr(s, ':');
	if (col)
	{	*col = '\0';
		col++;
	}

	nx = (EX *) emalloc(sizeof(EX));
	nx->f = (char *) emalloc(strlen(s)+1);
	strcpy(nx->f, s);
	if (col)
	{	nx->has_arg = 1;
		nx->arg_val = atoi(col);
	} else
		nx->has_arg = 0;
	nx->nxt = exs;
	exs = nx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0x30e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20388
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3080
cmpq $0x0, -0x18(%rbp)
je 0x203eb
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x3200
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x203f6
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq 0x65bbb(%rip), %rcx     # 0x85fb8
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x65ba8(%rip)     # 0x85fb8
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: uno_getref
SymRef *
uno_getref(symentry_t *t)
{	SymRef *r;

	if (dfs_free)
	{	r = dfs_free;
		dfs_free = dfs_free->nxt;
		r->sm = (symentry_t *) 0;
		r->n  = ZT;
		r->nxt = (SymRef *) 0;
		r->status = 0;
		r->s_val = 0;
	} else
		r = (SymRef *) emalloc(sizeof(SymRef));

	r->sm = t;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x65b7c(%rip)     # 0x85fb0
je 0x2048e
movq 0x65b73(%rip), %rax     # 0x85fb0
movq %rax, -0x10(%rbp)
movq 0x65b68(%rip), %rax     # 0x85fb0
movq 0x18(%rax), %rax
movq %rax, 0x65b5d(%rip)     # 0x85fb0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x2049c
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%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: uno_copy_ref
SymRef *
uno_copy_ref(SymRef *r)
{	SymRef *q;
	q = uno_getref(r->sm);
	q->n = r->n;
	q->status = r->status;
	q->s_val = r->s_val;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x20420
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%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: uno_getext
SymExt *
uno_getext(symentry_t *t)
{	SymExt *r;

	if (freesymext)
	{	r = freesymext;
		freesymext = r->nxt;
		memset(r, 0, sizeof(SymExt));
	} else
		r = (SymExt *) emalloc(sizeof(SymExt));
	r->sm = t;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x65a8c(%rip)     # 0x85fc0
je 0x20562
movq 0x65a83(%rip), %rax     # 0x85fc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x65a70(%rip)     # 0x85fc0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3140
jmp 0x20570
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%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: could_be_fct
void
could_be_fct(char *s)
{	Graphs *g;

	for (g = graph; g; g = g->nxt)
		if (strcmp(s, g->fctnm) == 0)
		{	if (debug)
			printf("uno: marking %s as fct in disguise\n", s);
			g->status |= 4;		/* cannot tell when this fct is called */
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x65a25(%rip), %rax     # 0x85fc8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x205ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x205ef
cmpl $0x0, 0x65a06(%rip)     # 0x85fd0
je 0x205de
movq -0x8(%rbp), %rsi
leaq 0x24aa3(%rip), %rdi     # 0x4507a
movb $0x0, %al
callq 0x30f0
movq -0x10(%rbp), %rax
movswl 0x42(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x42(%rax)
jmp 0x205ff
jmp 0x205f1
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x205a7
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: snap_add
int
snap_add(State *s, SymRef *r)
{	SymRef *t;

	for (t = s->snapshot; t; t = t->nxt)
		if (t->sm == r->sm
		&&  t->status == r->status)
			return 0;

	t = uno_getref(r->sm);
	t->status = r->status;
	t->n = r->n;
	t->nxt = s->snapshot;
	s->snapshot = t;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2066c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2065c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2065c
movl $0x0, -0x4(%rbp)
jmp 0x206bd
jmp 0x2065e
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2062c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x20420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_lts.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x206ee
cmpq $0x0, -0x18(%rbp)
jne 0x206f7
movl $0x0, -0x4(%rbp)
jmp 0x20770
movq -0x10(%rbp), %rax
cmpl $0x30, 0x1c(%rax)
jne 0x20769
movq -0x18(%rbp), %rax
cmpl $0x102, 0x18(%rax)      # imm = 0x102
jne 0x20769
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x20743
movq -0x28(%rbp), %rdi
leaq 0x24965(%rip), %rsi     # 0x4509e
callq 0x3160
cmpl $0x0, %eax
je 0x2075e
cmpl $0x0, -0x1c(%rbp)
jne 0x20767
movq -0x28(%rbp), %rdi
leaq 0x24952(%rip), %rsi     # 0x450a6
callq 0x3160
cmpl $0x0, %eax
jne 0x20767
movl $0x1, -0x4(%rbp)
jmp 0x20770
jmp 0x20769
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2096c
movl $0x0, -0x4(%rbp)
jmp 0x209b0
movq -0x10(%rbp), %rax
cmpl $0x1a, 0x1c(%rax)
jne 0x20988
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x20950
movl %eax, -0x4(%rbp)
jmp 0x209b0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x30, 0x1c(%rcx)
movb %al, -0x11(%rbp)
jne 0x209a5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20c96
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x20be0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22260
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x22320
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x22320
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%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 0x20(%rax), %rdi
callq 0x22370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x6539d(%rip), %rcx     # 0x86020
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x6538a(%rip)     # 0x86020
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_label
static LNode *
rel_label(LNode *n)
{
	if (n)
	{	rel_label(n->nxt);
		n->nxt = freelabels;
		freelabels = n;
	}
	return (LNode *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20cda
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x20ca0
movq 0x65379(%rip), %rcx     # 0x86040
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x65366(%rip)     # 0x86040
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_sframe
static Stack *
rel_sframe(Stack *f)
{
	if (f)
	{	rel_sframe(f->nxt);
		f->nxt = fol;
		fol = f;
	}
	return (Stack *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20d2a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x20cf0
movq 0x65331(%rip), %rcx     # 0x86048
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x6531e(%rip)     # 0x86048
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: lts_tree
static State *
lts_tree(State *n, treenode *root)
{	State *now = n;

	if (!root) return n;

	switch (root->hdr.which) {
	case IF_T:
		now = lts_if(now, (if_node *) root);
		break;

	case FOR_T:
		now = lts_for(now, (for_node *) root);
		break;

	case NODE_T:
		now = lts_node(now, root);
		break;

	case LEAF_T:
	case NONE_T:
		break;

	default:
		fprintf(stderr, "uno: unhandled type %s\n",
			name_of_nodetype(root->hdr.which));
		break;
	}
	return now;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2106c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21101
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x210cb
movq -0x28(%rbp), %rax
leaq 0x23cc5(%rip), %rcx     # 0x44d4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22580
movq %rax, -0x20(%rbp)
jmp 0x210f9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22790
movq %rax, -0x20(%rbp)
jmp 0x210f9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22c10
movq %rax, -0x20(%rbp)
jmp 0x210f9
jmp 0x210f9
movq 0x2cf26(%rip), %rax     # 0x4dff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x7ff0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x24088(%rip), %rsi     # 0x4517a
movb $0x0, %al
callq 0x3170
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: gen_dot
static void
gen_dot(void)
{	Graphs *g;

	printf("digraph dodot {\n");
	printf("	ratio=auto;\n");

	for (g = graph; g; g = g->nxt)
	{	/* printf("want %s, got %s\n", want, g->fctnm); */
		if (strcmp(want, g->fctnm) == 0)
		{	printf("N00 [label=\"%s\"];\n", want);
			printf("N00 -> N%p;\n", g->cfg->n);
			cfg_unvisit(g->all);
			gen_lts(g->cfg);
			printf("\n");
			break;
	}	}
	printf("}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x23fe4(%rip), %rdi     # 0x453a3
movb $0x0, %al
callq 0x30f0
leaq 0x23fe7(%rip), %rdi     # 0x453b4
movb $0x0, %al
callq 0x30f0
movq 0x64bed(%rip), %rax     # 0x85fc8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x21473
leaq 0x2cd57(%rip), %rax     # 0x4e148
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x21460
leaq 0x2cd3c(%rip), %rax     # 0x4e148
movq (%rax), %rsi
leaq 0x23fac(%rip), %rdi     # 0x453c2
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x23fa6(%rip), %rdi     # 0x453d5
movb $0x0, %al
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x242b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24310
leaq 0x232e8(%rip), %rdi     # 0x4473f
movb $0x0, %al
callq 0x30f0
jmp 0x21473
jmp 0x21462
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x213df
leaq 0x24884(%rip), %rdi     # 0x45cfe
movb $0x0, %al
callq 0x30f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)