LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: set_owner
void
set_owner(scopetab_t *p, char *s, int tp)
{	int i;

	if (0) printf("	setowner for %p %s %d (%s)\n", p, s, tp,
			p->owner?p->owner:"not yet set");

	if (p->owner) return;	/* already named */

	p->owner = s;
	p->owner_t = tp;

	for (i = 0; i < p->nchild; i++)		/* propagate to nested unnamed scopes */
		set_owner(p->children[i], s, tp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x60a0
jmp 0x60f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x60f0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x60bd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (DBG) printf("name_scope %p -- owner=%s (owner_t=%d) clevel %d, level %d\n",
		p->current,
		s, tp,
		p->clevel,
		p->current->level);
	set_owner(p->current, s, tp);

	if (Verbose&2)
	printf("SET level %d,%d, %s\n",
		p->clevel,  p->current->level,  s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6080
leaq 0x41b12(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6168
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rcx
leaq 0x2d024(%rip), %rdi     # 0x33185
movb $0x0, %al
callq 0x4120
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: new_symtab
symtab_t*
new_symtab(void)
{	symtab_t *that;

	if (freesymt)
	{	that = freesymt;
		freesymt = that->nxt;
		memset(that, 0, sizeof(symtab_t));
	} else
		that = (symtab_t *) e_malloc(sizeof(symtab_t));

	that->root = new_scopetab(NULL);
	that->clevel = EXTERN_SCOPE;
	that->current = that->root;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x41a28(%rip)     # 0x47ba8
je 0x61ae
movq 0x41a1f(%rip), %rax     # 0x47ba8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x41a0c(%rip)     # 0x47ba8
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4160
jmp 0x61bc
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x52c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_lookup
symentry_t*
symtab_lookup(symtab_t *that, str_t *nme)
{	symentry_t *ret = NULL;

	if (that->current)
		ret = scopetab_find(that->current, nme);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6238
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert
symentry_t*
symtab_insert(symtab_t *that, symentry_t *entry)
{	symentry_t *t;
#if DBG
	printf("	symtab insert %s (clevel %d currentlevel %d) %u\n",
		entry->nme->str, that->clevel, that->current->level, entry);
#endif
	while (that->clevel > that->current->level)
	{	scopetab_t *child = new_scopetab(that->current);

		if (!child || !child_insert(that->current,child))
			return NULL;

		that->current = child;
	}
	t = scopetab_insert(that->current,entry);
#if DBG
	printf("	inserted at %u\n", t);
#endif
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jle 0x62ba
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x62a2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x62f0
cmpl $0x0, %eax
jne 0x62ac
movq $0x0, -0x8(%rbp)
jmp 0x62d7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6260
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: child_insert
static int
child_insert(scopetab_t *mom, scopetab_t *kid)
{	int j;

	if (0)
	printf("		child insert - level %d\n", mom->level);

	if (mom->nchild >= mom->size)
	{	scopetab_t **oldkids = mom->children;
		mom->size += mom->size;
		mom->children = (scopetab_t **) e_malloc( sizeof(scopetab_t*) * mom->size );

		for (j=0; j < mom->nchild; j++)
			mom->children[j] = oldkids[j];
	}

	mom->children[mom->nchild] = kid;
	(mom->nchild)++;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jl 0x6387
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movslq 0x2c(%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x6385
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6352
jmp 0x6387
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert_at
symentry_t *
symtab_insert_at(symtab_t *that, symentry_t *entry, int level)
{	scopetab_t *scp;
	scopetab_t *child;

#ifdef  MORE_VERBOSE
	printf("scope level %d; ",   that->current->level);
	printf("current level %d; ", that->clevel);
	printf("request level %d\n", level);
#endif

	while ((that->clevel >  that->current->level)
	    && (that->clevel >= level))
	{
		child = new_scopetab(that->current);

		if (!child
		||  !child_insert(that->current,child))
			return (symentry_t *) 0;

		that->current = child;
	}

	scp = that->current;

	while (scp && (scp->level > level))
		scp = scp->parent;

	if (scp)
		return scopetab_insert(scp,entry);

	return (symentry_t *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x31(%rbp)
jle 0x63fc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
setge %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6405
jmp 0x644b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6433
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x62f0
cmpl $0x0, %eax
jne 0x643d
movq $0x0, -0x8(%rbp)
jmp 0x64ac
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x63d3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x32(%rbp)
je 0x6473
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
setg %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x647c
jmp 0x648a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6457
cmpq $0x0, -0x28(%rbp)
je 0x64a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54e0
movq %rax, -0x8(%rbp)
jmp 0x64ac
movq $0x0, -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]Modex/Src/symtab.c
// Function: add_fctnm
void
add_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return;
	}	}
	f = (NameList *) e_malloc(sizeof(NameList));
	f->nm = s;
	f->nxt = fctnms;
	fctnms = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x4163d(%rip), %rax     # 0x47bb0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x65a5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6595
jmp 0x65d8
jmp 0x6597
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6577
movl $0x10, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x415eb(%rip), %rcx     # 0x47bb0
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x415d8(%rip)     # 0x47bb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: is_fctnm
int
is_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return 1;
	}	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x415bd(%rip), %rax     # 0x47bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x662c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x661c
movl $0x1, -0x4(%rbp)
jmp 0x6633
jmp 0x661e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x65f7
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]Modex/Src/symtab.c
// Function: save_fcts
void
save_fcts(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	int j;

	for (z = that; z; z = z->parent)
	{	if (z->owner
		&&  z->owner_t == TN_FUNC_DEF
		&&  strcmp(z->owner, "-") != 0)
		{	add_fctnm(z->owner);
	}	}

	for (j = 0; j < that->nchild; j++)
		save_fcts(that->children[j], fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x66aa
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x669a
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x669a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2e5d1(%rip), %rsi     # 0x34c54
callq 0x4180
cmpl $0x0, %eax
je 0x669a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6560
jmp 0x669c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6658
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x66e1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x6640
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66b1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) e_malloc( sizeof(context_t) );

	that->labels = new_symtab();
	that->tags   = new_symtab();
	that->syms   = new_symtab();

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x8(%rbp)
callq 0x6170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x6170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x6170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: exit_scopes
void
exit_scopes(context_t *that, int newlev)
{
	if (newlev < EXTERN_SCOPE)
		newlev = EXTERN_SCOPE;

	while (newlev < that->syms->current->level)
		exit_scope(that);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x67dc
movl $0x1, -0xc(%rbp)
jmp 0x67de
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x67fd
movq -0x8(%rbp), %rdi
callq 0x6780
jmp 0x67de
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: add_constant
void
add_constant(char *p, int isvis)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->isvis = isvis;
	s->nxt = cnames;
	cnames = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x41392(%rip), %rax     # 0x47bb8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6858
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6848
jmp 0x68c3
jmp 0x684a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x682a
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%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 -0x8(%rbp), %rsi
callq 0x40a0
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x41308(%rip), %rcx     # 0x47bb8
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x412f5(%rip)     # 0x47bb8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: is_constant
int
is_constant(char *p)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x412d5(%rip), %rax     # 0x47bb8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6927
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6917
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x692e
jmp 0x6919
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x68e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: do_constants
void
do_constants(FILE *fd)
{	Cname *s;
	int i = 1;

	if (!cnames) return;

	fprintf(fd, "\n");
	for (s = cnames; s; s = s->nxt)
	{	if (s->purged)
		{	continue;
		}
		s->purged = 1;
		if (s->isvis)
		{	fprintf(fd, "hidden int %s = %d;\n", s->vn, i++);
	}	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0x0, 0x4125d(%rip)     # 0x47bb8
jne 0x6962
jmp 0x69ed
movq -0x8(%rbp), %rdi
leaq 0x2f0ea(%rip), %rsi     # 0x35a57
movb $0x0, %al
callq 0x4190
movq 0x4123d(%rip), %rax     # 0x47bb8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x69db
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x6992
jmp 0x69cd
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x69cb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl -0x14(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq 0x2c7d6(%rip), %rsi     # 0x3319a
movb $0x0, %al
callq 0x4190
jmp 0x69cd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x697f
movq -0x8(%rbp), %rdi
leaq 0x2f071(%rip), %rsi     # 0x35a57
movb $0x0, %al
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: add_icall
void
add_icall(char *p)
{	Cname *s;

	for (s = icalls; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->nxt = icalls;
	icalls = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x411ad(%rip), %rax     # 0x47bc0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6a45
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6a35
jmp 0x6aa6
jmp 0x6a37
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6a17
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq 0x4112d(%rip), %rcx     # 0x47bc0
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x4111a(%rip)     # 0x47bc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: is_icall
int
is_icall(char *p)
{	Cname *s;

	for (s = icalls; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x410fd(%rip), %rax     # 0x47bc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6b07
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6af7
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6b0e
jmp 0x6af9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ac7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: add_pname
void
add_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->nxt = pnames;
	pnames = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x41095(%rip), %rax     # 0x47bc8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b65
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6b55
jmp 0x6bc6
jmp 0x6b57
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6b37
movl $0x20, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq 0x41015(%rip), %rcx     # 0x47bc8
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x41002(%rip)     # 0x47bc8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: is_pname
int
is_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x40fe5(%rip), %rax     # 0x47bc8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c27
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x6c17
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6c2e
jmp 0x6c19
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6be7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: print_frag
static void
print_frag(treenode *root, FILE *fd)
{
	fprintf(fd, "\t[");	/* source text */
	if (root && (root->hdr.which != FOR_T))
		fprintf(fd, "%s", x_stmnt(root));
	else
		fprintf(fd, "fct");
	fprintf(fd, "]");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2c522(%rip), %rsi     # 0x331cd
movb $0x0, %al
callq 0x4190
cmpq $0x0, -0x8(%rbp)
je 0x6cea
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
je 0x6cea
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xacc0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2eae0(%rip), %rsi     # 0x357c1
movb $0x0, %al
callq 0x4190
jmp 0x6cfc
movq -0x10(%rbp), %rdi
leaq 0x2c4db(%rip), %rsi     # 0x331d0
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rdi
leaq 0x2c42a(%rip), %rsi     # 0x33131
movb $0x0, %al
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: new_cmd
void
new_cmd(char c, char *s, int h)
{	Cmd *cmd;

	if (!s)
	{	fprintf(stderr, "modex: bad argument to '%c'\n", c);
		exit(1);
	}

	if (c == 'e')	// instrumented function
	{	add_icall(s);
	}
	if (c == 'p')	// passive proctype
	{	add_pname(s);
	}

	cmd = (Cmd *) e_malloc(sizeof(Cmd));
	memset(cmd, 0, sizeof(Cmd));
	cmd->cmd = c;
	cmd->n = nrprocs;
	cmd->arg = (char *) e_malloc(strlen(s)+1);
	strcpy(cmd->arg, s);

	if (Verbose_cmds)
	{	printf("New cmd <%c> <%s> <called from: %d> (nrprocs %d)\n", c, s, h, nrprocs);
	}

	if (cmds)
	{	cmds->nxt = cmd;
	}
	cmds = cmd;

	if (!ncmd)
	{	ncmd = cmds;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7272
movq 0x3dda5(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movsbl -0x1(%rbp), %edx
leaq 0x2d033(%rip), %rsi     # 0x34294
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movsbl -0x1(%rbp), %eax
cmpl $0x65, %eax
jne 0x7284
movq -0x10(%rbp), %rdi
callq 0x6a00
movsbl -0x1(%rbp), %eax
cmpl $0x70, %eax
jne 0x7296
movq -0x10(%rbp), %rdi
callq 0x6b20
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
movsbl -0x1(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl 0x3df0c(%rip), %ecx     # 0x451d0
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
cmpl $0x0, 0x408ea(%rip)     # 0x47bec
je 0x7324
movsbl -0x1(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl 0x3deba(%rip), %r8d     # 0x451d0
leaq 0x2cf94(%rip), %rdi     # 0x342b1
movb $0x0, %al
callq 0x4120
cmpq $0x0, 0x408c4(%rip)     # 0x47bf0
je 0x733d
movq -0x20(%rbp), %rcx
movq 0x408b7(%rip), %rax     # 0x47bf0
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x408a8(%rip)     # 0x47bf0
cmpq $0x0, 0x408a8(%rip)     # 0x47bf8
jne 0x7360
movq 0x40897(%rip), %rax     # 0x47bf0
movq %rax, 0x40898(%rip)     # 0x47bf8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: expand_cmd
void
expand_cmd(char c, char *s, int h)	// e.g., s="one,two,three"
{	char *z = s;

	while (s != NULL && (z = strchr(s, ',')) != NULL)
	{	*z = '\0';
		new_cmd(c, s, h);
		s = z+1;
	}
	if (s != NULL)	// last one in list
	{	new_cmd(c, s, h);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x73b5
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x73be
jmp 0x73e5
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movsbl %al, %edi
callq 0x7230
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x738d
cmpq $0x0, -0x10(%rbp)
je 0x73fe
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movsbl %al, %edi
callq 0x7230
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: mkfo
void
mkfo(char *fnm)
{
	if ((fo = fopen(fnm, MFLAGS)) == NULL)
	{	fprintf(stderr, "modex: checkprx: cannot create %s\n", fnm);
		exit(1);
	}
if (debug_io) fprintf(stderr, "Open %s -> %p\n", fnm, fo);

	add_fnm(fnm);
	/* printf("	%s\n", fnm); */
	nfls++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x32578(%rip), %rsi     # 0x3adaf
callq 0x4230
movq %rax, 0x3f65d(%rip)     # 0x47ea0
cmpq $0x0, %rax
jne 0x886f
movq 0x3c7a8(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2bb9c(%rip), %rsi     # 0x343fa
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
cmpl $0x0, 0x3f372(%rip)     # 0x47be8
je 0x889b
movq 0x3c779(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq 0x3f613(%rip), %rcx     # 0x47ea0
leaq 0x2bb89(%rip), %rsi     # 0x3441d
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
callq 0x10500
movl 0x3f5fe(%rip), %eax     # 0x47ea8
addl $0x1, %eax
movl %eax, 0x3f5f5(%rip)     # 0x47ea8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: header
void
header(char *bnm, char *suffix1)
{	char *fnm;

	if (fo)
	{	if (incode && !inltl) fprintf(fo, "}\n");
		if (fo != fdrv)
		{	if (debug_io)
			{	fprintf(stderr, "close 3 %p\n", fo);
			}
			Fclose(fo);
	}	}
	inlut = incode = inspn = indfn = ingui = inltl = 0;

	fnm = (char *) e_malloc(strlen(bnm)+strlen(suffix1)+1);
	strcpy(fnm, bnm);
	strcat(fnm, suffix1);

	if (strcmp(suffix1, ".drv") == 0)
	{	if (!hasdrv)
		{	mkfo(fnm);
			fdrv = fo;
			hasdrv = 1;
			/* include global header file by default */
			fprintf(fdrv, "#include \"_modex_.h\"\n");
		} else
			fo = fdrv;
	} else
	{	mkfo(fnm);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x3f5c8(%rip)     # 0x47ea0
je 0x8947
cmpl $0x0, 0x3f5cb(%rip)     # 0x47eac
je 0x8901
cmpl $0x0, 0x3f5c6(%rip)     # 0x47eb0
jne 0x8901
movq 0x3f5ad(%rip), %rdi     # 0x47ea0
leaq 0x2e7c0(%rip), %rsi     # 0x370ba
movb $0x0, %al
callq 0x4190
movq 0x3f598(%rip), %rax     # 0x47ea0
cmpq 0x3f5a9(%rip), %rax     # 0x47eb8
je 0x8945
cmpl $0x0, 0x3f2d0(%rip)     # 0x47be8
je 0x8939
movq 0x3c6d7(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq 0x3f575(%rip), %rdx     # 0x47ea0
leaq 0x2bafa(%rip), %rsi     # 0x3442c
movb $0x0, %al
callq 0x4190
movq 0x3f560(%rip), %rdi     # 0x47ea0
callq 0x6d20
jmp 0x8947
movl $0x0, 0x3f55f(%rip)     # 0x47eb0
movl $0x0, 0x3f565(%rip)     # 0x47ec0
movl $0x0, 0x3f55f(%rip)     # 0x47ec4
movl $0x0, 0x3f559(%rip)     # 0x47ec8
movl $0x0, 0x3f533(%rip)     # 0x47eac
movl $0x0, 0x3f549(%rip)     # 0x47ecc
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4250
movq -0x10(%rbp), %rdi
leaq 0x2ba61(%rip), %rsi     # 0x34438
callq 0x4180
cmpl $0x0, %eax
jne 0x8a32
cmpl $0x0, 0x3f4e8(%rip)     # 0x47ed0
jne 0x8a22
movq -0x18(%rbp), %rdi
callq 0x8820
movq 0x3f4a6(%rip), %rax     # 0x47ea0
movq %rax, 0x3f4b7(%rip)     # 0x47eb8
movl $0x1, 0x3f4c5(%rip)     # 0x47ed0
movq 0x3f4a6(%rip), %rdi     # 0x47eb8
leaq 0x2ba24(%rip), %rsi     # 0x3443d
movb $0x0, %al
callq 0x4190
jmp 0x8a30
movq 0x3f48f(%rip), %rax     # 0x47eb8
movq %rax, 0x3f470(%rip)     # 0x47ea0
jmp 0x8a3b
movq -0x18(%rbp), %rdi
callq 0x8820
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: Arg_Add
void
Arg_Add(char *s, char *t)
{
	if (strlen(s) == 0) return;

	if (Verbose_cmds)
		printf("add arg %s %s\n", s, t);

	if (Argc >= 128)
	{	fprintf(stderr, "modex: too many arguments\n");
		exit(1);
	}
	Argv[Argc] = (char *) e_malloc(strlen(s)+strlen(t)+1);
	strcpy(Argv[Argc], s);
	strcat(Argv[Argc], t);

	if (Verbose_cmds)
		printf("	[%d] -> <%s>\n", Argc, Argv[Argc]);
	Argc++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
cmpq $0x0, %rax
jne 0x8a74
jmp 0x8b75
cmpl $0x0, 0x3f171(%rip)     # 0x47bec
je 0x8a93
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x2b9c7(%rip), %rdi     # 0x34453
movb $0x0, %al
callq 0x4120
cmpl $0x80, 0x3c74b(%rip)    # 0x451e8
jl 0x8ac1
movq 0x3c552(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2b9b2(%rip), %rsi     # 0x34462
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rdx
movslq 0x3c6f2(%rip), %rcx     # 0x451e8
leaq 0x3f3e3(%rip), %rax     # 0x47ee0
movq %rdx, (%rax,%rcx,8)
movslq 0x3c6e0(%rip), %rcx     # 0x451e8
leaq 0x3f3d1(%rip), %rax     # 0x47ee0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movslq 0x3c6c5(%rip), %rcx     # 0x451e8
leaq 0x3f3b6(%rip), %rax     # 0x47ee0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4250
cmpl $0x0, 0x3f0ae(%rip)     # 0x47bec
je 0x8b66
movl 0x3c6a2(%rip), %esi     # 0x451e8
movslq 0x3c69b(%rip), %rcx     # 0x451e8
leaq 0x3f38c(%rip), %rax     # 0x47ee0
movq (%rax,%rcx,8), %rdx
leaq 0x2b91e(%rip), %rdi     # 0x3447d
movb $0x0, %al
callq 0x4120
movl 0x3c67c(%rip), %eax     # 0x451e8
addl $0x1, %eax
movl %eax, 0x3c673(%rip)     # 0x451e8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: Add_Args
void
Add_Args(char *s)
{	char *t, *v;

	if (Verbose_cmds)
		printf("add args <%s>\n", s);

	for (t = v = s; *t; t++)
		if (*t == ' ' || *t == '\t')
		{	*t = '\0';
			Arg_Add(v, "");
			v = t+1;
			while (*v == ' ' || *v == '\t')
				v++;
			t = v;
		}
	Arg_Add(v, "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x3f059(%rip)     # 0x47bec
je 0x8ba7
movq -0x8(%rbp), %rsi
leaq 0x2b8ec(%rip), %rdi     # 0x3448c
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8c4e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x8bd8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x8c3b
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
leaq 0x2e8d4(%rip), %rsi     # 0x374be
callq 0x8a50
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x19(%rbp)
je 0x8c1c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8c25
jmp 0x8c33
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8bfb
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8c3d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8bb3
movq -0x18(%rbp), %rdi
leaq 0x2e865(%rip), %rsi     # 0x374be
callq 0x8a50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: boiler_plate
void
boiler_plate(FILE *fd, int pre)
{
	fprintf(fd, "\t\tif [ -f _modex_.drv ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"error: no ./_modex_.drv file\"\n");
	fprintf(fd, "\t\t	exit 1\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\t%s model pan.? pan pan.exe _spin_nvr.tmp\n\n", RM);
	fprintf(fd, "\t\tif [ -f _modex_.h ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"\" > _modex_.h\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\techo \"// Generated by %s\" > model\n", VERSION);
	fprintf(fd, "\t\techo \"// `date` from %s\" >> model\n", file_name);
	fprintf(fd, "\t\techo \"\" >> model\n");
	fprintf(fd, "\t\tif [ -f _modex_.b4g ]\n");
	fprintf(fd, "\t\tthen	cat _modex_.b4g >> model\n");
	fprintf(fd, "\t\tfi\n");
	fprintf(fd, "\t\t%s _modex_.drv | grep -v -e '^$' -e '^# ' >> model", CPP);
	if (pre)
	{	fprintf(fd, " 2>&1");
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b83c(%rip), %rsi     # 0x34506
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b843(%rip), %rsi     # 0x3451f
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b83e(%rip), %rsi     # 0x3452c
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b858(%rip), %rsi     # 0x34558
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b851(%rip), %rsi     # 0x34563
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b846(%rip), %rsi     # 0x3456a
leaq 0x2b86c(%rip), %rdx     # 0x34597
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b860(%rip), %rsi     # 0x3459d
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b7d0(%rip), %rsi     # 0x3451f
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b853(%rip), %rsi     # 0x345b4
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b7f0(%rip), %rsi     # 0x34563
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq 0x3c3db(%rip), %rdx     # 0x45160
leaq 0x2b844(%rip), %rsi     # 0x345d0
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq 0x3eeba(%rip), %rdx     # 0x47c58
leaq 0x2b850(%rip), %rsi     # 0x345f5
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b863(%rip), %rsi     # 0x3461a
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b865(%rip), %rsi     # 0x3462e
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b86c(%rip), %rsi     # 0x34647
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b87b(%rip), %rsi     # 0x34668
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2b86f(%rip), %rsi     # 0x3466e
leaq 0x2b89d(%rip), %rdx     # 0x346a3
movb $0x0, %al
callq 0x4190
cmpl $0x0, -0xc(%rbp)
je 0x8e25
movq -0x8(%rbp), %rdi
leaq 0x2b891(%rip), %rsi     # 0x346af
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x2cc27(%rip), %rsi     # 0x35a57
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/modex.c
// Function: add_to_file
void
add_to_file(char *buf)
{	char *z;
	int i;

	if (fo && (inlut || incode || inspn || indfn))
	{	if (inspn && (z = strstr(buf, "\\#")) != NULL)
			*z = '\n';
		fprintf(fo, "%s\n", buf);
	} else if (ingui)
		for (i = 0; params[i].descr; i++)
		{	z = params[i].descr;
			if (!strncmp(buf, z, strlen(z)))
				*params[i].val = atoi(&buf[strlen(z)]);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x3e7bc(%rip)     # 0x47ea0
je 0x9752
cmpl $0x0, 0x3e7df(%rip)     # 0x47ecc
jne 0x970a
cmpl $0x0, 0x3e7b6(%rip)     # 0x47eac
jne 0x970a
cmpl $0x0, 0x3e7c9(%rip)     # 0x47ec8
jne 0x970a
cmpl $0x0, 0x3e7bc(%rip)     # 0x47ec4
je 0x9752
cmpl $0x0, 0x3e7b7(%rip)     # 0x47ec8
je 0x9734
movq -0x8(%rbp), %rdi
leaq 0x2b2d0(%rip), %rsi     # 0x349ee
callq 0x4280
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9734
movq -0x10(%rbp), %rax
movb $0xa, (%rax)
movq 0x3e765(%rip), %rdi     # 0x47ea0
movq -0x8(%rbp), %rdx
leaq 0x2bf23(%rip), %rsi     # 0x35669
movb $0x0, %al
callq 0x4190
jmp 0x9814
cmpl $0x0, 0x3e767(%rip)     # 0x47ec0
je 0x9812
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x3ba7f(%rip), %rax     # 0x451f0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x9810
movslq -0x14(%rbp), %rcx
leaq 0x3ba63(%rip), %rax     # 0x451f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x4090
cmpl $0x0, %eax
jne 0x9800
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq -0x30(%rbp), %rdi
addq %rax, %rdi
callq 0x4240
movl %eax, %ecx
movslq -0x14(%rbp), %rdx
leaq 0x3b9fd(%rip), %rax     # 0x451f0
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
jmp 0x9802
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9766
jmp 0x9812
jmp 0x9814
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: close_file
void
close_file(void)
{
	if (incode && !inltl)  fprintf(fo, "}\n");
	if (fo && fo != fdrv)
	{
if (debug_io) fprintf(stderr, "close 5 %p\n", fo);
		Fclose(fo);
	}
	fo = NULL;
	inlut = incode = inspn = inltl = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x3e681(%rip)     # 0x47eac
je 0x984b
cmpl $0x0, 0x3e67c(%rip)     # 0x47eb0
jne 0x984b
movq 0x3e663(%rip), %rdi     # 0x47ea0
leaq 0x2d876(%rip), %rsi     # 0x370ba
movb $0x0, %al
callq 0x4190
cmpq $0x0, 0x3e64d(%rip)     # 0x47ea0
je 0x9899
movq 0x3e644(%rip), %rax     # 0x47ea0
cmpq 0x3e655(%rip), %rax     # 0x47eb8
je 0x9899
cmpl $0x0, 0x3e37c(%rip)     # 0x47be8
je 0x988d
movq 0x3b783(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq 0x3e621(%rip), %rdx     # 0x47ea0
leaq 0x2b16b(%rip), %rsi     # 0x349f1
movb $0x0, %al
callq 0x4190
movq 0x3e60c(%rip), %rdi     # 0x47ea0
callq 0x6d20
movq $0x0, 0x3e5fc(%rip) # 0x47ea0
movl $0x0, 0x3e602(%rip)     # 0x47eb0
movl $0x0, 0x3e610(%rip)     # 0x47ec8
movl $0x0, 0x3e5ea(%rip)     # 0x47eac
movl $0x0, 0x3e600(%rip)     # 0x47ecc
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: check_param
void
check_param(char *cmd)		/* check for filename param */
{	FILE *fd;
	char buf[1024], *fnm;

	fnm = &cmd[2];
	while (*fnm == ' ' || *fnm == '\t')
		fnm++;

	if (!*fnm) return;	/* must be inline contents */

	if ((fd = fopen(fnm, "r")) == NULL)
	{	if (cmd[1] != 'L')
			fprintf(stderr, "modex: no such file %s\n", cmd);
		return;
	}
if (debug_io) fprintf(stderr, "Open %s -> %p\n", fnm, fd);

	while (fgets(buf, sizeof(buf), fd))
		add_to_file(buf);

if (debug_io) fprintf(stderr, "close 6 %p\n", fd);
	Fclose(fd);
	close_file();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x419(%rbp)
je 0x991b
movq -0x418(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x419(%rbp)
movb -0x419(%rbp), %al
testb $0x1, %al
jne 0x9927
jmp 0x993b
movq -0x418(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x98ee
movq -0x418(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x994c
jmp 0x9a21
movq -0x418(%rbp), %rdi
leaq 0x2c749(%rip), %rsi     # 0x360a3
callq 0x4230
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x9997
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x4c, %eax
je 0x9992
movq 0x3b67b(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2b072(%rip), %rsi     # 0x349fd
movb $0x0, %al
callq 0x4190
jmp 0x9a21
cmpl $0x0, 0x3e24a(%rip)     # 0x47be8
je 0x99c3
movq 0x3b651(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x418(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x2aa61(%rip), %rsi     # 0x3441d
movb $0x0, %al
callq 0x4190
jmp 0x99c5
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x4170
cmpq $0x0, %rax
je 0x99ee
leaq -0x410(%rbp), %rdi
callq 0x96d0
jmp 0x99c5
cmpl $0x0, 0x3e1f3(%rip)     # 0x47be8
je 0x9a13
movq 0x3b5fa(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2b009(%rip), %rsi     # 0x34a15
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0x6d20
callq 0x9820
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: add_sed
void
add_sed(char *z)
{	char *n;
	int ln = strlen(z);
	if (strcmp(sedproc_info, "cat") == 0)
	{	n = (char *) e_malloc(ln + 1);
		strcpy(n, z);
	} else
	{	ln += strlen(sedproc_info) + strlen(" | ");
		n = (char *) e_malloc(ln + 1);
		sprintf(n, "%s | %s", sedproc_info, z);
	}
	sedproc_info = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movl %eax, -0x14(%rbp)
movq 0x3b759(%rip), %rdi     # 0x451a8
leaq 0x29bab(%rip), %rsi     # 0x33601
callq 0x4180
cmpl $0x0, %eax
jne 0x9a7e
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
jmp 0x9ac7
movq 0x3b723(%rip), %rdi     # 0x451a8
callq 0x40f0
movq %rax, %rcx
addq $0x3, %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x3b6f3(%rip), %rdx     # 0x451a8
movq -0x8(%rbp), %rcx
leaq 0x2af61(%rip), %rsi     # 0x34a21
movb $0x0, %al
callq 0x4260
movq -0x10(%rbp), %rax
movq %rax, 0x3b6d6(%rip)     # 0x451a8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/modex.c
// Function: newer
static int
newer(char *f1, char *f2)
{	struct stat x, y;

	if (stat(f1, (struct stat *)&x) < 0) return 0; /* no .c file */
	if (stat(f2, (struct stat *)&y) < 0) return 1; /* no .M file */
	if (x.st_mtime < y.st_mtime) return 0;
	
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x41a0
cmpl $0x0, %eax
jge 0xa5a1
movl $0x0, -0x4(%rbp)
jmp 0xa5dc
movq -0x18(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x41a0
cmpl $0x0, %eax
jge 0xa5bf
movl $0x1, -0x4(%rbp)
jmp 0xa5dc
movq -0x50(%rbp), %rax
cmpq -0xe0(%rbp), %rax
jge 0xa5d5
movl $0x0, -0x4(%rbp)
jmp 0xa5dc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: x_stmnt
char *
x_stmnt(treenode *n)	/* service routine for lts.c */
{	char *p;

	if (!n) return "--";
	if (n->hdr.type == TN_STEMNT)
		return "<stmnt>";
	if (n->hdr.type == TN_BLOCK)
		return "<block>";

	fp = 0;
	do_level = 0;
	visu = 1;
	OutBuf[0] = '\0';
	modex_recur(n);
	visu = 0;
	for (p = OutBuf; *p != '\0'; p++)
		if (*p == '"') *p = '\'';

	return OutBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xace3
leaq 0x29f79(%rip), %rax     # 0x34c53
movq %rax, -0x8(%rbp)
jmp 0xad9b
movq -0x10(%rbp), %rax
cmpl $0x23, 0x1c(%rax)
jne 0xacfd
leaq 0x2a568(%rip), %rax     # 0x3525c
movq %rax, -0x8(%rbp)
jmp 0xad9b
movq -0x10(%rbp), %rax
cmpl $0x4, 0x1c(%rax)
jne 0xad17
leaq 0x2a556(%rip), %rax     # 0x35264
movq %rax, -0x8(%rbp)
jmp 0xad9b
movq $0x0, 0x3d81e(%rip) # 0x48540
movl $0x0, 0x3d81c(%rip)     # 0x48548
leaq 0x3ce6d(%rip), %rax     # 0x47ba0
movl $0x1, (%rax)
movb $0x0, 0x3d810(%rip)     # 0x48550
movq -0x10(%rbp), %rdi
callq 0xadb0
leaq 0x3ce50(%rip), %rax     # 0x47ba0
movl $0x0, (%rax)
leaq 0x3d7f3(%rip), %rax     # 0x48550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xad90
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0xad80
movq -0x18(%rbp), %rax
movb $0x27, (%rax)
jmp 0xad82
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xad61
leaq 0x3d7b9(%rip), %rax     # 0x48550
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/xtract.c
// Function: nx_stmnt
char *
nx_stmnt(treenode *n)
{
	if (!n
	||  n->hdr.type == TN_STEMNT
	||  n->hdr.type == TN_BLOCK)
	{	return "";
	}

	do_level = 0;

	visu = 1;
	OutBuf[0] = '\0';
	modex_recur(n);
	visu = 0;

	strcpy(fct_name, "--");
	IntBuf[0] = '\0';

	return rm_decor(OutBuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc8b7
movq -0x10(%rbp), %rax
cmpl $0x23, 0x1c(%rax)
je 0xc8b7
movq -0x10(%rbp), %rax
cmpl $0x4, 0x1c(%rax)
jne 0xc8c4
leaq 0x2ac00(%rip), %rax     # 0x374be
movq %rax, -0x8(%rbp)
jmp 0xc922
movl $0x0, 0x3bc7a(%rip)     # 0x48548
leaq 0x3b2cb(%rip), %rax     # 0x47ba0
movl $0x1, (%rax)
movb $0x0, 0x3bc6e(%rip)     # 0x48550
movq -0x10(%rbp), %rdi
callq 0xadb0
leaq 0x3b2ae(%rip), %rax     # 0x47ba0
movl $0x0, (%rax)
leaq 0x38a61(%rip), %rdi     # 0x45360
leaq 0x2834d(%rip), %rsi     # 0x34c53
callq 0x40a0
movb $0x0, 0x3cc3e(%rip)     # 0x49550
leaq 0x3bc37(%rip), %rdi     # 0x48550
callq 0xc930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)