LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: tree_parse
int
tree_parse(TreeStack *treestk, int parse_all)
{
    int cnt = 0;

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

    do {
#if 0
        while(yyparse())
            ;
#else
	yyparse();	/* returns 1 on error 0 on accept */
#endif
        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 0x1c920
cmpl $0x0, %eax
je 0x1ca5d
movl $0x0, -0x4(%rbp)
jmp 0x1ca94
jmp 0x1ca5f
callq 0x28f00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1caa0
movq -0x10(%rbp), %rdi
callq 0x1c920
cmpl $0x0, %eax
je 0x1ca86
jmp 0x1ca8e
jmp 0x1ca88
cmpl $0x0, -0x14(%rbp)
jne 0x1ca5f
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]Modex/Src/treestk.c
// Function: get_next_file
int
get_next_file(TreeStack *treestk)
{
    if (is_empty(treestk)){
        Parse_TOS = (Stk_Item *) NULL;
        return(0);
    }

    if (DoneStack)
        push(DoneStack, pop(treestk));
    else {
        fputs("DoneStack was NULL.\n", stdout);
        delete_stk_item(pop(treestk));
    }

    reset_position(treestk);

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

    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c920
cmpl $0x0, %eax
je 0x1cad4
leaq 0x2b117(%rip), %rax     # 0x47bd8
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1cb54
leaq 0x2b105(%rip), %rax     # 0x47be0
cmpq $0x0, (%rax)
je 0x1cb06
leaq 0x2b0f8(%rip), %rax     # 0x47be0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c8b0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1c860
jmp 0x1cb2d
movq 0x284c3(%rip), %rax     # 0x44fd0
movq (%rax), %rsi
leaq 0x1b89c(%rip), %rdi     # 0x383b3
callq 0x4150
movq -0x10(%rbp), %rdi
callq 0x1c8b0
movq %rax, %rdi
callq 0x1c7b0
movq -0x10(%rbp), %rdi
callq 0x1c9d0
movq -0x10(%rbp), %rdi
callq 0x1c920
cmpl $0x0, %eax
je 0x1cb4d
movl $0x0, -0x4(%rbp)
jmp 0x1cb54
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: handle_new_file
void
handle_new_file(TreeStack *treestk, FILE *fp, char *fname)
{
    Stk_Item *stk_item;

    if ((stk_item = new_stk_item(fp, fname)) == NULL)
        return;

    push(treestk, stk_item);
    reset_position(treestk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c640
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1cb8d
jmp 0x1cba3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c860
movq -0x8(%rbp), %rdi
callq 0x1c9d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: doit
char *
doit(leafnode *leaf, int how)
{	scopetab_t *z;
	static char bstr[1024];
	static char lstr[1024];

	if (!leaf) return (char *) 0;

	if (leaf->syment && leaf->syment->nes)
		z = leaf->syment->nes;
	else
		z = (scopetab_t *) 0;

	strcpy(lstr, "");
	switch (how) {
	case 2:	sprintf(bstr, "%d:", leaf->hdr.line);
		strcat(lstr, bstr);	/* fall thru */
	case 0:	sprintf(bstr, "%s::", z?z->owner:"-");
		strcat(lstr, bstr);	/* fall thru */
	case 1:	sprintf(bstr, "%s%s", nmestr(leaf->data.sval), (!how)?" ":"");
		strcat(lstr, bstr);
	}
	return &lstr[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d203
movq $0x0, -0x8(%rbp)
jmp 0x2d354
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2d22f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2d22f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d237
movq $0x0, -0x20(%rbp)
leaq 0x2eaa2(%rip), %rdi     # 0x5bce0
leaq 0xa279(%rip), %rsi      # 0x374be
callq 0x40a0
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2d2a1
jmp 0x2d256
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x2d2ef
jmp 0x2d264
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0x2d349
jmp 0x2d272
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x2e660(%rip), %rdi     # 0x5b8e0
leaq 0xa338(%rip), %rsi      # 0x375bf
movb $0x0, %al
callq 0x4260
leaq 0x2ea4b(%rip), %rdi     # 0x5bce0
leaq 0x2e644(%rip), %rsi     # 0x5b8e0
callq 0x4250
cmpq $0x0, -0x20(%rbp)
je 0x2d2b6
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2d2c3
leaq 0x7997(%rip), %rax      # 0x34c54
movq %rax, -0x30(%rbp)
jmp 0x2d2c3
movq -0x30(%rbp), %rdx
leaq 0x2e612(%rip), %rdi     # 0x5b8e0
leaq 0x116e3(%rip), %rsi     # 0x3e9b8
movb $0x0, %al
callq 0x4260
leaq 0x2e9fd(%rip), %rdi     # 0x5bce0
leaq 0x2e5f6(%rip), %rsi     # 0x5b8e0
callq 0x4250
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4870
movq %rax, %rdx
cmpl $0x0, -0x14(%rbp)
setne %sil
xorb $-0x1, %sil
leaq 0xa1ac(%rip), %rcx      # 0x374be
leaq 0x8d47(%rip), %rax      # 0x36060
testb $0x1, %sil
cmovneq %rax, %rcx
leaq 0x2e5b8(%rip), %rdi     # 0x5b8e0
leaq 0x1168e(%rip), %rsi     # 0x3e9bd
movb $0x0, %al
callq 0x4260
leaq 0x2e9a3(%rip), %rdi     # 0x5bce0
leaq 0x2e59c(%rip), %rsi     # 0x5b8e0
callq 0x4250
leaq 0x2e990(%rip), %rax     # 0x5bce0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: dep_node
DuG *
dep_node(SymList *a, int imark)
{	DuG *g;

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

	g = (DuG *) e_malloc(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 = du_g;
	du_g = g;
done:
	return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x2ed6a(%rip), %rax     # 0x5c0e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d3b4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2d3a4
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x2d434
jmp 0x2d3a6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d37a
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2d3e5
leaq 0x17d9c(%rip), %rax     # 0x45170
movq (%rax), %rsi
leaq 0x115e4(%rip), %rdi     # 0x3e9c2
movb $0x0, %al
callq 0x4120
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 0x2ece4(%rip), %ecx     # 0x5c0e8
movq -0x18(%rbp), %rax
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x2ecbf(%rip), %rcx     # 0x5c0e0
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x2ecac(%rip)     # 0x5c0e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: dep_edge
int
dep_edge(DuG *a, DuG *b, int dist)
{	DuGP *e;

	if (a->sm == b->sm)
		return 0;		/* self-loop */

	for (e = a->d_e; e; e = e->nxt)
	{	if (e->ptr == b)
			return 0;	/* already there */
	}

	e = (DuGP *) e_malloc(sizeof(DuGP));
	e->ptr = b;
	e->dist = dist;
	e->nxt = a->d_e;
	a->d_e = e;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2d46c
movl $0x0, -0x4(%rbp)
jmp 0x2d4eb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2d4a5
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x2d495
movl $0x0, -0x4(%rbp)
jmp 0x2d4eb
jmp 0x2d497
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d478
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -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]Modex/Src/dflow.c
// Function: dep_trans
void
dep_trans(void)	/* transitive closure */
{	DuG *g, *t;
	DuGP *s, *u;
	int dist, cnt;

	do {	cnt = 0;
		for (g = du_g; g; g = g->nxt)
		for (s = g->d_e; s; s = s->nxt)			/* successors */
		{	t = s->ptr;				/* one successor in DuG */
			for (u = t->d_e; u; u = u->nxt)		/* the successors of this */
			{	dist = s->dist + u->dist;
				if (dep_edge(g, u->ptr, dist))
					cnt++;
			}
		}
	} while (cnt > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x28(%rbp)
movq 0x2ebca(%rip), %rax     # 0x5c0e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2d5bb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d5a8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2d598
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %edx
callq 0x2d440
cmpl $0x0, %eax
je 0x2d588
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2d58a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d54f
jmp 0x2d59a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d531
jmp 0x2d5aa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d51a
jmp 0x2d5bd
cmpl $0x0, -0x28(%rbp)
jg 0x2d508
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: dep_warn
void
dep_warn(int m)
{
	if (!(m&DEF) || !(m&USE))
	{
		if (!(m&DEF))
			fprintf(stdout, "\t%snever defined",
				(m&USE)?"used but ":"never used and ");
		else if (!(m&USE))
			fprintf(stdout, "\tdefined but never used");
	}
	fprintf(stdout, "%s\n", (m&HIDE)?" hidden":"");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2d5f1
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x2d658
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2d631
movq 0x179cd(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
movl -0x4(%rbp), %ecx
andl $0x4, %ecx
leaq 0x113e7(%rip), %rdx     # 0x3e9fa
leaq 0x113d6(%rip), %rax     # 0x3e9f0
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq 0x113b7(%rip), %rsi     # 0x3e9df
movb $0x0, %al
callq 0x4190
jmp 0x2d656
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x2d654
movq 0x1798d(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
leaq 0x113bd(%rip), %rsi     # 0x3ea0a
movb $0x0, %al
callq 0x4190
jmp 0x2d656
jmp 0x2d658
movq 0x17971(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
movl -0x4(%rbp), %ecx
andl $0x200, %ecx            # imm = 0x200
leaq 0x9e4c(%rip), %rdx      # 0x374be
leaq 0x113a9(%rip), %rax     # 0x3ea22
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq 0x7fe2(%rip), %rsi      # 0x35669
movb $0x0, %al
callq 0x4190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: dep_graph
void
dep_graph(DefUse *d)
{	SymList *s, *t;
	DuG *a, *b;

	if (!d || preview) return;

	if (!d->def)
	for (t = d->use; t; t = t->nxt)
		dep_node(t, USE);

	for (s = d->def; s; s = s->nxt)
	{	a = dep_node(s, DEF);
		for (t = d->use; t; t = t->nxt)
		{	b = dep_node(t, USE);
			if (s->sm != t->sm)
				dep_edge(a, b, 1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2d8af
leaq 0x1a362(%rip), %rax     # 0x47c0c
cmpl $0x0, (%rax)
je 0x2d8b4
jmp 0x2d981
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2d8f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d8ee
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x2d360
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d8cb
jmp 0x2d8f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d981
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2d360
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d96e
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x2d360
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x2d95e
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x2d440
jmp 0x2d960
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d921
jmp 0x2d970
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d8fc
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: mark_defs
void
mark_defs(DefUse *d, int how, FILE *fp)	/* how=0: keep or map, HIDE: comment, print or hide */
{	SymList *s;
	DuG *g;

	for (s = d->def; s; s = s->nxt)
	for (g = du_g; g; g = g->nxt)
		if (g->sm == s->sm)
		{
			if ((g->marks & (DEF|(how&~HIDE))) != (DEF|(how&~HIDE)))
				fprintf(fp, "markdefs:%s: %d <-> %d | %d\n",
					g->sm->nme->str, g->marks, DEF, (how&~HIDE));
			g->marks |= (DEF|how);
		}

	for (s = d->use; s; s = s->nxt)
	for (g = du_g; g; g = g->nxt)
		if (g->sm == s->sm)
		{
			if ((g->marks & USE) != USE)
				fprintf(fp, "markdefs:%s: %d <-> %d\n",
					g->sm->nme->str, g->marks, USE);
			g->marks |= USE;	/* no hide's here */
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2da75
movq 0x2e71f(%rip), %rax     # 0x5c0e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2da62
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2da4f
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x1, %ecx
andl %ecx, %eax
movl -0xc(%rbp), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x1, %ecx
cmpl %ecx, %eax
je 0x2da3f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0xc(%rbp), %r9d
andl $0xfffffdff, %r9d       # imm = 0xFFFFFDFF
leaq 0x11003(%rip), %rsi     # 0x3ea35
movl $0x1, %r8d
movb $0x0, %al
callq 0x4190
movl -0xc(%rbp), %ecx
orl $0x1, %ecx
movq -0x28(%rbp), %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x2da51
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d9c5
jmp 0x2da64
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d9af
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2db1c
movq 0x2e64d(%rip), %rax     # 0x5c0e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2db09
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2daf9
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x4, %eax
je 0x2daec
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x10f73(%rip), %rsi     # 0x3ea52
movl $0x4, %r8d
movb $0x0, %al
callq 0x4190
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x8(%rax)
jmp 0x2dafb
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2da97
jmp 0x2db0b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2da81
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: attach_defuse
void
attach_defuse(treenode *n, char *t, DefUse *d)
{
	if (!d || !n) return;

	if (d->def || d->use)
		dep_graph(d);	/* update the graph */

	if (n->hdr.defuse)
	{	if (n->hdr.defuse != d
		&&  !same_defuse(d, n->hdr.defuse))
		{	printf("%s: %s:%d attach_defuse conflict %s %s\n",
				progname, n->hdr.fnm, n->hdr.line,
#ifdef DEFTYP
				n->hdr.deftyp,
#else
				"",
#endif
				t);
			printf("OLD:\n");
			dump_defuse(n->hdr.defuse, stdout);
			printf("\nNEW:\n");
			dump_defuse(d, stdout);
			printf("\n");
		}
	} else
	{	n->hdr.defuse = d;
#ifdef DEFTYP
		n->hdr.deftyp = t;
#endif
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2dea2
cmpq $0x0, -0x8(%rbp)
jne 0x2dea7
jmp 0x2df95
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2debd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2dec6
movq -0x18(%rbp), %rdi
callq 0x2d890
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2df89
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x2df87
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2dfa0
cmpl $0x0, %eax
jne 0x2df87
leaq 0x17268(%rip), %rax     # 0x45170
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %r9
leaq 0x10b60(%rip), %rdi     # 0x3ea85
leaq 0x9592(%rip), %r8       # 0x374be
movb $0x0, %al
callq 0x4120
leaq 0x10b73(%rip), %rdi     # 0x3eaad
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x17080(%rip), %rax     # 0x44fd0
movq (%rax), %rsi
callq 0x2db30
leaq 0x10b54(%rip), %rdi     # 0x3eab3
movb $0x0, %al
callq 0x4120
movq -0x18(%rbp), %rdi
movq 0x1705f(%rip), %rax     # 0x44fd0
movq (%rax), %rsi
callq 0x2db30
leaq 0x7ad7(%rip), %rdi      # 0x35a57
movb $0x0, %al
callq 0x4120
jmp 0x2df95
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/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 *) e_malloc(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, 0x2df39(%rip)     # 0x5c0f0
je 0x2e1e8
movq 0x2df30(%rip), %rax     # 0x5c0f0
movq %rax, -0x18(%rbp)
movq 0x2df25(%rip), %rax     # 0x5c0f0
movq 0x18(%rax), %rax
movq %rax, 0x2df1a(%rip)     # 0x5c0f0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4160
jmp 0x2e1f6
movl $0x20, %edi
callq 0x4a70
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 0x2ded9(%rip), %rcx     # 0x5c0f8
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x2dec6(%rip)     # 0x5c0f8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: set_fbase
void
set_fbase(int ln, char *s)
{	Fbase *f;

	if (!show_funcs) fbase = (Fbase *) 0;

	f = (Fbase *) e_malloc(sizeof(Fbase));
	f->nm = (char *) e_malloc(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)
leaq 0x199ee(%rip), %rax     # 0x47c44
cmpl $0x0, (%rax)
jne 0x2e266
movq $0x0, 0x2de9a(%rip) # 0x5c100
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x2de41(%rip), %rcx     # 0x5c100
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x2de2e(%rip)     # 0x5c100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: act_fcall
void
act_fcall(FILE *fd, Fbase *f)
{
	if (!f) return;
	act_fcall(fd, f->fcalls);

	if (!f->fcalls
	||  strcmp(f->fcalls->nm, f->nm) != 0)
		fprintf(fd, "\n	%s\t", f->nm);
	fprintf(fd, "%d ", f->ln);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e2f9
jmp 0x2e363
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2e2e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2e331
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
je 0x2e34a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x10777(%rip), %rsi     # 0x3eaba
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x6668(%rip), %rsi      # 0x349c4
movb $0x0, %al
callq 0x4190
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: act_fbase
void
act_fbase(FILE *fd, Fbase *f)
{
	if (!f) return;
	act_fbase(fd, f->nxt);

/*	fprintf(fd, "%s	%d", f->nm, f->ln);	*/
	act_fcall(fd, f->fcalls);	/* reverse order */
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e389
jmp 0x2e3bd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2e370
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2e2e0
movq -0x8(%rbp), %rdi
leaq 0x76a1(%rip), %rsi      # 0x35a57
movb $0x0, %al
callq 0x4190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: bugger
void
bugger(char *store, treenode *root, int top)
{	leafnode *leaf;

	if (!root) return;

	switch (root->hdr.which) {
	case LEAF_T:
		leaf = (leafnode *) root;
		switch (leaf->hdr.type) {
		case TN_IDENT:
			strcat(store, leaf->data.sval->str);
			break;
		default:
			goto bad;
		}
		break;
	case NODE_T:
		switch (root->hdr.type) {
		case TN_SELECT:
			bugger(store, root->lnode, 0);
			if (root->hdr.tok == ARROW)
				strcat(store, "->");
			else
				strcat(store, ".");
			bugger(store, root->rnode, 0);
			break;
		case TN_FUNC_CALL:
			bugger(store, root->lnode, 0);
			strcat(store, "()");
			break;
		default:
			goto bad;
		}
		break;
	default:
bad:		strcat(store, "<unknown type>");
		break;
	}

	if (top) strcat(store, "()");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e47f
jmp 0x2e596
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x2e49c
jmp 0x2e48f
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0x2e4d3
jmp 0x2e56e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
subl $0x2d, %eax
jne 0x2e4c9
jmp 0x2e4b2
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4250
jmp 0x2e4ce
jmp 0x2e570
jmp 0x2e580
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x3, %eax
je 0x2e545
jmp 0x2e4e4
movl -0x28(%rbp), %eax
subl $0x27, %eax
jne 0x2e56a
jmp 0x2e4ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %edx, %edx
callq 0x2e460
movq -0x10(%rbp), %rax
cmpl $0x175, 0x18(%rax)      # imm = 0x175
jne 0x2e520
movq -0x8(%rbp), %rdi
leaq 0x7b10(%rip), %rsi      # 0x36029
callq 0x4250
jmp 0x2e530
movq -0x8(%rbp), %rdi
leaq 0x8412(%rip), %rsi      # 0x3693d
callq 0x4250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
xorl %edx, %edx
callq 0x2e460
jmp 0x2e56c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %edx, %edx
callq 0x2e460
movq -0x8(%rbp), %rdi
leaq 0x7585(%rip), %rsi      # 0x35ae8
callq 0x4250
jmp 0x2e56c
jmp 0x2e570
jmp 0x2e580
jmp 0x2e570
movq -0x8(%rbp), %rdi
leaq 0x106ea(%rip), %rsi     # 0x3ec65
callq 0x4250
cmpl $0x0, -0x14(%rbp)
je 0x2e596
movq -0x8(%rbp), %rdi
leaq 0x7557(%rip), %rsi      # 0x35ae8
callq 0x4250
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: add_fbase
static void
add_fbase(int ln, char *s)
{	Fbase *f, *g;

	if (!visu && !show_funcs) return;

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

	f = (Fbase *) e_malloc(sizeof(Fbase));
	f->nm = (char *) e_malloc(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 0x195ea(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x2e5cc
leaq 0x19682(%rip), %rax     # 0x47c44
cmpl $0x0, (%rax)
jne 0x2e5cc
jmp 0x2e6c0
cmpq $0x0, 0x2db2c(%rip)     # 0x5c100
jne 0x2e5e7
leaq 0x16b9b(%rip), %rax     # 0x45178
movq (%rax), %rsi
xorl %edi, %edi
callq 0x2e240
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
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 0x2dab4(%rip), %rax     # 0x5c100
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2e69e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x2e68e
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 0x2e6c0
jmp 0x2e690
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e654
movq 0x2da5b(%rip), %rax     # 0x5c100
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq 0x2da44(%rip), %rax     # 0x5c100
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: sym_babble
static void
sym_babble(leafnode *leaf, unsigned long mark)
{	char *q = "--";
	scopetab_t *s = (scopetab_t *) 0;

	if (!leaf) return;

	if (leaf->syment
	&&  leaf->syment->nes)
		s = leaf->syment->nes;	/* name enclosing scope */

	fprintf(stdout, "%3d, %s::%s\t",
		leaf->hdr.line, s?s->owner:"-",
		nmestr(leaf->data.sval));
	if (s)
	switch (s->owner_t) {
	case TN_OBJ_DEF: q = "struct/union"; break;
	case TN_FUNC_DEF: q = "fnct"; break;
	}

	fprintf(stdout, "(%s) ", q);
	dflow_mark(stdout, mark);

	if (s && leaf->syment)
	{	find_symbol(leaf->syment->nes, leaf->syment);
		if (s->owner_t == TN_OBJ_DEF)
			printf(" prior use: %d",
				leaf->syment->used);
	}
	fprintf(stdout, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4f7c(%rip), %rax      # 0x34c53
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2fcef
jmp 0x2fe5a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2fd19
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2fd19
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x152b0(%rip), %rax     # 0x44fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2fd46
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2fd53
leaq 0x4f07(%rip), %rax      # 0x34c54
movq %rax, -0x38(%rbp)
jmp 0x2fd53
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4870
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x40(%rbp), %rcx
movq %rax, %r8
leaq 0xeef7(%rip), %rsi      # 0x3ec74
movb $0x0, %al
callq 0x4190
cmpq $0x0, -0x20(%rbp)
je 0x2fdc0
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x2fdb3
jmp 0x2fd9c
movl -0x44(%rbp), %eax
subl $0x18, %eax
jne 0x2fdbe
jmp 0x2fda6
leaq 0xeed4(%rip), %rax      # 0x3ec81
movq %rax, -0x18(%rbp)
jmp 0x2fdbe
leaq 0xee22(%rip), %rax      # 0x3ebdc
movq %rax, -0x18(%rbp)
jmp 0x2fdc0
movq 0x15209(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xeeb9(%rip), %rsi      # 0x3ec8e
movb $0x0, %al
callq 0x4190
movq 0x151ed(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0x2e6d0
cmpq $0x0, -0x20(%rbp)
je 0x2fe42
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2fe42
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x5690
movq -0x20(%rbp), %rax
cmpl $0x18, 0x20(%rax)
jne 0x2fe40
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movsbl 0x22(%rax), %esi
leaq 0xee5b(%rip), %rdi      # 0x3ec94
movb $0x0, %al
callq 0x4120
jmp 0x2fe42
movq 0x15187(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
leaq 0x5c04(%rip), %rsi      # 0x35a57
movb $0x0, %al
callq 0x4190
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: set_u
static char *
set_u(struct symentry *x, char *nu)
{	char *u;

	if (!Fct_name) goto isglob;

	if (!x)
	{	u = (char *) e_malloc(strlen(nu)+strlen(Fct_name)+1-1);
		sprintf(u, "%s%s", Fct_name, &nu[1]);
	} else if (x->decl_level == 0)
	{	u = (char *) e_malloc(strlen(nu)+strlen("fct")+1-1);
		sprintf(u, "%s%s", "fct", &nu[1]);
	} else if (x->decl_level == 3)	/* is local */
	{	u = (char *) e_malloc(strlen(nu)+strlen(Fct_name)+1-1);
		sprintf(u, "%s%s", Fct_name, &nu[1]);
	} else	/* extern 1 or global 2 */
	{
isglob:		u = (char *) e_malloc(strlen(nu)+strlen("glob")+1-1);
		sprintf(u, "%s%s", "glob", &nu[1]);
	}
	return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x2ca98(%rip)     # 0x5c910
jne 0x2fe7f
jmp 0x2ff9d
cmpq $0x0, -0x8(%rbp)
jne 0x2fee2
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq 0x2ca76(%rip), %rdi     # 0x5c910
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
subq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x2ca49(%rip), %rdx     # 0x5c910
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq 0xeae7(%rip), %rsi      # 0x3e9bd
movb $0x0, %al
callq 0x4260
jmp 0x2ffe2
movq -0x8(%rbp), %rax
movswl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x2ff35
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x3, %rax
addq $0x1, %rax
subq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq 0xea9b(%rip), %rsi      # 0x3e9bd
leaq 0x32a7(%rip), %rdx      # 0x331d0
movb $0x0, %al
callq 0x4260
jmp 0x2ffe0
movq -0x8(%rbp), %rax
movswl 0x20(%rax), %eax
cmpl $0x3, %eax
jne 0x2ff9b
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, -0x28(%rbp)
movq 0x2c9ba(%rip), %rdi     # 0x5c910
callq 0x40f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
subq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x2c98d(%rip), %rdx     # 0x5c910
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq 0xea2b(%rip), %rsi      # 0x3e9bd
movb $0x0, %al
callq 0x4260
jmp 0x2ffde
jmp 0x2ff9d
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x4, %rax
addq $0x1, %rax
subq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq 0xe9ed(%rip), %rsi      # 0x3e9bd
leaq 0xeccc(%rip), %rdx      # 0x3eca3
movb $0x0, %al
callq 0x4260
jmp 0x2ffe0
jmp 0x2ffe2
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/dflow.c
// Function: merge_lists
static DefUse *
merge_lists(DefUse *d1, DefUse *d2)
{	DefUse *nd;

	if (!d1) return d2;
	if (!d2) return d1;

	nd = (DefUse *) e_malloc(sizeof(DefUse));
	if (!preview)
	{	nd->def   = merge_syms(d1->def, d2->def);
		nd->use   = merge_syms(d1->use, d2->use);
	}
	nd->other = merge_syms(d1->other, d2->other);

	return nd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30014
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x300aa
cmpq $0x0, -0x18(%rbp)
jne 0x30028
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x300aa
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
leaq 0x17bcf(%rip), %rax     # 0x47c0c
cmpl $0x0, (%rax)
jne 0x30082
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x300f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x300f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x300f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%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]Modex/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;
#if 0
	printf("merge%d:\t", mcnt++);
	for (t = s1; t; t = t->nxt)
	printf("%s, ", t->sm->nme->str);
	printf("\nand:\t");
	for (t = s2; t; t = t->nxt)
	printf("%s, ", t->sm->nme->str);
	printf("\n\n");
	/* if (mcnt > 11) abort(); */
#endif

	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 0x30124
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30218
cmpq $0x0, -0x18(%rbp)
jne 0x30138
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30218
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x301eb
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3018e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x3017e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x3017e
jmp 0x3018e
jmp 0x30180
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x30153
cmpq $0x0, -0x20(%rbp)
jne 0x301d8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2e1a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x301c2
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x301d6
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x301d8
jmp 0x301da
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x30140
cmpq $0x0, -0x40(%rbp)
jne 0x301fc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30218
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)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/prnttree.c
// Function: print_recur
void
print_recur(treenode *root, FILE *fp)
{
	can_flush = fp;
	strcpy(PBuf, "");
	do_recur(root, 0);
	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, 0x2c6d5(%rip)     # 0x5c920
leaq 0x2c6de(%rip), %rdi     # 0x5c930
leaq 0x7265(%rip), %rsi      # 0x374be
callq 0x40a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x302a0
movq -0x10(%rbp), %rdi
leaq 0x554d(%rip), %rsi      # 0x357c1
leaq 0x2c6b5(%rip), %rdx     # 0x5c930
movb $0x0, %al
callq 0x4190
movq $0x0, 0x2c693(%rip) # 0x5c920
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/prnttree.c
// Function: print2buf
char *
print2buf(treenode *root)
{	// small fragments
	strcpy(PBuf, "");
	do_recur(root, 0);
	return PBuf; // read only
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2b1dd(%rip), %rdi     # 0x5c930
leaq 0x5d64(%rip), %rsi      # 0x374be
callq 0x40a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x302a0
leaq 0x2b1bf(%rip), %rax     # 0x5c930
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/prnttree.c
// Function: fput_meta
static void
fput_meta(int c, int in_str)
{	char s[2];

	switch (c) {
	case '\'':
		strcat(PBuf, in_str ? "'" : "\\'");
		break;
	case '"':
		strcat(PBuf, in_str ? "\\\"" : "\"");
		break;
	case '\0':
		strcat(PBuf, "\\0");
		break;
	case '\\':
		strcat(PBuf, "\\\\");
		break;
	case '\n':
		strcat(PBuf, "\\n");
		break;
	case '\t':
		strcat(PBuf, "\\t");
		break;
	case '\r':
		strcat(PBuf, "\\r");
		break;
	case '\f':
		strcat(PBuf, "\\f");
		break;
	case '\b':
		strcat(PBuf, "\\b");
		break;
	case '\v':
		strcat(PBuf, "\\v");
		break;
	case '\a':
		strcat(PBuf, "\\a");
		break;
	case '%':
		strcat(PBuf, "%%");	/* NEW */
		break;
	default:
		s[0] = c; s[1] = '\0';
		strcat(PBuf, s);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5c, %rax
ja 0x31976
movq -0x18(%rbp), %rax
leaq 0xd566(%rip), %rcx      # 0x3eda0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %ecx
leaq 0x4846(%rip), %rsi      # 0x36093
leaq 0x9142(%rip), %rax      # 0x3a996
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x2b0ce(%rip), %rdi     # 0x5c930
callq 0x4250
jmp 0x31990
movl -0x8(%rbp), %ecx
leaq 0xdb26(%rip), %rsi      # 0x3f39c
leaq 0x4819(%rip), %rax      # 0x36096
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x2b0a5(%rip), %rdi     # 0x5c930
callq 0x4250
jmp 0x31990
leaq 0x2b094(%rip), %rdi     # 0x5c930
leaq 0x47f6(%rip), %rsi      # 0x36099
callq 0x4250
jmp 0x31990
leaq 0x2b07c(%rip), %rdi     # 0x5c930
leaq 0x47e1(%rip), %rsi      # 0x3609c
callq 0x4250
jmp 0x31990
leaq 0x2b064(%rip), %rdi     # 0x5c930
leaq 0x1901(%rip), %rsi      # 0x331d4
callq 0x4250
jmp 0x31990
leaq 0x2b04c(%rip), %rdi     # 0x5c930
leaq 0x47b4(%rip), %rsi      # 0x3609f
callq 0x4250
jmp 0x31990
leaq 0x2b034(%rip), %rdi     # 0x5c930
leaq 0x479f(%rip), %rsi      # 0x360a2
callq 0x4250
jmp 0x31990
leaq 0x2b01c(%rip), %rdi     # 0x5c930
leaq 0x478a(%rip), %rsi      # 0x360a5
callq 0x4250
jmp 0x31990
leaq 0x2b007(%rip), %rdi     # 0x5c930
leaq 0x4778(%rip), %rsi      # 0x360a8
callq 0x4250
jmp 0x31990
leaq 0x2aff2(%rip), %rdi     # 0x5c930
leaq 0x4766(%rip), %rsi      # 0x360ab
callq 0x4250
jmp 0x31990
leaq 0x2afdd(%rip), %rdi     # 0x5c930
leaq 0x4754(%rip), %rsi      # 0x360ae
callq 0x4250
jmp 0x31990
leaq 0x2afc8(%rip), %rdi     # 0x5c930
leaq 0x390f(%rip), %rsi      # 0x3527e
callq 0x4250
jmp 0x31990
movl -0x4(%rbp), %eax
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
leaq 0x2afa5(%rip), %rdi     # 0x5c930
callq 0x4250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex_pp.c
// Function: avoid_name_clash
static void
avoid_name_clash(char *p, char *s)
{	char *q;
	int n = strlen(s);
	int m = strlen(p);

	while (m > 0 && (q = strstr(p, s)) != NULL)
	{	if (*(q-1) != '_'
		&& !isalnum((int)*(q-1))
		&&  *(q+n) != '_'
		&& !isalnum((int)*(q+n)))
		{	*q = toupper((int) *q);
		}
		p = q+n;
		m = strlen(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
jle 0x3216e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3217a
jmp 0x3220e
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5f, %eax
je 0x321ee
callq 0x4290
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x321ee
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x321ee
callq 0x4290
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x321ee
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x40b0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movl %eax, -0x20(%rbp)
jmp 0x32148
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/ps_graph.c
// Function: dot_start
void
dot_start(treenode *root)
{
DTREE	{
	printf("digraph dodot {\n");
	printf("	ratio=auto;\n");
	/* printf("	page=\"8.3x11.7\";\n");	*/
	}

	dot_tree(root);

DTREE	printf("\n}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcc81(%rip), %rdi      # 0x3f344
movb $0x0, %al
callq 0x4120
leaq 0xcc84(%rip), %rdi      # 0x3f355
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rdi
callq 0x32700
leaq 0x3efe(%rip), %rdi      # 0x365e6
movb $0x0, %al
callq 0x4120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/ps_graph.c
// Function: dot_tree
void
dot_tree(treenode *root)
{
	if (!root) return;

DTREE	printf("N%lu [label=\"%s\"];\n",
		(unsigned long) root,
		name_of_node(root->hdr.type));
DTREE	if (root->hdr.defuse) {
		printf("N%lu -> f%lu;\n",
			(unsigned long) root,
			(unsigned long) root);
		printf("f%lu [shape=box,label=\"",
			(unsigned long) root);
		dump_defuse(root->hdr.defuse, stdout);
		printf("\"];\n");
	}

	switch (root->hdr.which) {
	case IF_T:
		dot_if((if_node *) root);
		break;

	case FOR_T:
		dot_for((for_node *) root);
		break;

	case LEAF_T:
		dot_leaf((leafnode *) root);
		break;

	case NODE_T:
		dot_node(root);
		break;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x32718
jmp 0x3282c
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1bc40
movq -0x10(%rbp), %rsi
movq %rax, %rdx
leaq 0xcc29(%rip), %rdi      # 0x3f363
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x32799
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0xcc1c(%rip), %rdi      # 0x3f377
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rsi
leaq 0xcc19(%rip), %rdi      # 0x3f386
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x1284d(%rip), %rax     # 0x44fd0
movq (%rax), %rsi
callq 0x2db30
leaq 0xccca(%rip), %rdi      # 0x3f45c
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x327ec
movq -0x18(%rbp), %rax
leaq 0xca89(%rip), %rcx      # 0x3f240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x32840
jmp 0x3282c
movq -0x8(%rbp), %rdi
callq 0x32960
jmp 0x3282c
movq -0x8(%rbp), %rdi
callq 0x324a0
jmp 0x3282c
movq -0x8(%rbp), %rdi
callq 0x32ae0
jmp 0x3282c
movq 0x12805(%rip), %rax     # 0x44ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x1296f(%rip), %rax     # 0x45170
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1b9c0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0xcb79(%rip), %rsi      # 0x3f39e
movb $0x0, %al
callq 0x4190
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/ps_graph.c
// Function: dot_if
DTREE	if (root->hdr.defuse) {
		printf("N%lu -> f%lu;\n",
			(unsigned long) root,
			(unsigned long) root);
		printf("f%lu [shape=box,label=\"",
			(unsigned long) root);
		dump_defuse(root->hdr.defuse, stdout);
		printf("\"];\n");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x32858
jmp 0x3294e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3288b
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0xcb3f(%rip), %rdi      # 0x3f3b5
movb $0x0, %al
callq 0x4120
leaq 0xcb3e(%rip), %rdi      # 0x3f3c2
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x328be
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
leaq 0xcb0c(%rip), %rdi      # 0x3f3b5
movb $0x0, %al
callq 0x4120
leaq 0xcb1d(%rip), %rdi      # 0x3f3d4
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x328f1
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xcad9(%rip), %rdi      # 0x3f3b5
movb $0x0, %al
callq 0x4120
leaq 0xcafe(%rip), %rdi      # 0x3f3e8
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
cmpl $0x159, 0x18(%rax)      # imm = 0x159
jne 0x32927
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x32700
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32700
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x32700
jmp 0x3294e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x32700
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32700
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x32700
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/tools/oshrun.c
// Function: cleanup
int cleanup(void) {
	int rc = 0;
	char shm[64];
	int i = 0;
	while (1) {
		snprintf(shm, sizeof(shm), "/dev/shm/shmem_init.%d.%d", getpid(), i++);
		struct stat sb;
		if (!stat(shm, &sb)) {
			if (remove(shm)) rc = 1;
		}
		else return rc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xf0(%rbp)
callq 0x1050
movq -0xf0(%rbp), %rdi
movl %eax, %ecx
movl -0x54(%rbp), %r8d
movl %r8d, %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movl $0x40, %esi
leaq 0x1003(%rip), %rdx      # 0x229e
movb $0x0, %al
callq 0x1070
leaq -0x50(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x12ce
leaq -0x50(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
je 0x12cc
movl $0x1, -0x4(%rbp)
jmp 0x12da
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
jmp 0x1269
nopl (%rax)