LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: prop_debug
void
prop_debug(treenode *n, int level, char letter)
{	int i;

	if (!n) return;

	printf("%c: ", letter);

	for (i = 0; i < level; i++)
		printf("  ");

	printf("(%s) %s, %s",
		toksym(n->hdr.tok, 0),
		name_of_nodetype(n->hdr.which),
		name_of_node(n->hdr.type));

	if (n->hdr.type == TN_IDENT)
	{	printf("\t(%s)\n", ((leafnode *)n)->data.sval->str);
		return;
	}
	printf("\n");
	prop_debug(n->lnode, level+1, 'L');
	prop_debug(n->rnode, level+1, 'R');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17890
jmp 0x17974
movsbl -0xd(%rbp), %esi
leaq 0x1ec87(%rip), %rdi     # 0x36522
movb $0x0, %al
callq 0x4120
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x178ca
leaq 0x1e7a7(%rip), %rdi     # 0x3605f
movb $0x0, %al
callq 0x4120
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x178a9
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
xorl %esi, %esi
callq 0x1ab20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1b9c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1bc40
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x1ec1e(%rip), %rdi     # 0x36527
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x17936
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1ec06(%rip), %rdi     # 0x36533
movb $0x0, %al
callq 0x4120
jmp 0x17974
leaq 0x1e11a(%rip), %rdi     # 0x35a57
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0x4c, %edx
callq 0x17870
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0x52, %edx
callq 0x17870
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: cnt_commas
int
cnt_commas(treenode *n)
{
	if (!n) return 0;

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

	return cnt_commas(n->lnode)
	     + cnt_commas(n->rnode)
	     + (n->hdr.tok == COMMA);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1799c
movl $0x0, -0x4(%rbp)
jmp 0x179ec
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x179af
movl $0x0, -0x4(%rbp)
jmp 0x179ec
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x17980
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x17980
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl $0x14c, 0x18(%rcx)      # imm = 0x14C
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: ax_terms
void
ax_terms(Ax_Props *np, treenode *n)
{
	if (!n) return;

	if (n->hdr.tok == COMMA)
	{	ax_terms(np, n->lnode);
		ax_terms(np, n->rnode);
	} else
	{	int i;
		for (i = 0; i < 2; i++)
			if (!np->terms[i])
			{	strcpy(Rem3, OutBuf);
				strcpy(OutBuf, "");
				modex_recur(n);
				np->terms[i] = (char *) e_malloc(strlen(OutBuf)+1);
				strcpy(np->terms[i], OutBuf);
				strcpy(OutBuf, Rem3);
				return;
			}
		fprintf(stderr, "%s: Error, too many npterms\n", progname);
		exit(1);	/* cannot happen */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17a1c
jmp 0x17b35
movq -0x10(%rbp), %rax
cmpl $0x14c, 0x18(%rax)      # imm = 0x14C
jne 0x17a50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x17a00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x17a00
jmp 0x17b35
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x17b09
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x17af9
leaq 0x3cb24(%rip), %rdi     # 0x545a0
leaq 0x30acd(%rip), %rsi     # 0x48550
callq 0x40a0
leaq 0x30ac1(%rip), %rdi     # 0x48550
leaq 0x1fa28(%rip), %rsi     # 0x374be
callq 0x40a0
movq -0x10(%rbp), %rdi
callq 0xadb0
leaq 0x30aa5(%rip), %rdi     # 0x48550
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
leaq 0x30a71(%rip), %rsi     # 0x48550
callq 0x40a0
leaq 0x30a65(%rip), %rdi     # 0x48550
leaq 0x3caae(%rip), %rsi     # 0x545a0
callq 0x40a0
jmp 0x17b35
jmp 0x17afb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17a57
movq 0x2d4e8(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2d656(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq 0x1ea16(%rip), %rsi     # 0x3653a
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: ax_new_assert
void
ax_new_assert(const int t, treenode *n)
{	Ax_Props *np;

	if (Verbose&2) prop_debug(n, 0, 'T');

	if (t > 1 || t < 0 || !n || cnt_commas(n) != t)
	{	if (n) fprintf(stderr, "%s: error, %s:%d, assert_%s, ",
			progname, n->hdr.fnm, n->hdr.line, t?"r":"p");
		fprintf(stderr, " (saw %d commas)\n", cnt_commas(n));
		return;
	}

	np = (Ax_Props *) e_malloc(sizeof(Ax_Props));
	np->t = t;
	np->n = n;
	np->nr = ax_prop_nr;
	np->terms[0] = (char *) 0;
	np->terms[1] = (char *) 0;
	ax_terms(np, n);

	np->nxt = all_props;
	all_props = np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x300f6(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x17b70
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x54, %edx
callq 0x17870
cmpl $0x1, -0x4(%rbp)
jg 0x17b91
cmpl $0x0, -0x4(%rbp)
jl 0x17b91
cmpq $0x0, -0x10(%rbp)
je 0x17b91
movq -0x10(%rbp), %rdi
callq 0x17980
cmpl -0x4(%rbp), %eax
je 0x17c0f
cmpq $0x0, -0x10(%rbp)
je 0x17be2
movq 0x2d459(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2d5c7(%rip), %rax     # 0x45170
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
movl -0x4(%rbp), %esi
leaq 0x2020b(%rip), %r9      # 0x37dd1
leaq 0x1e4d6(%rip), %rax     # 0x360a3
cmpl $0x0, %esi
cmovneq %rax, %r9
leaq 0x1e97c(%rip), %rsi     # 0x36557
movb $0x0, %al
callq 0x4190
movq 0x2d40f(%rip), %rax     # 0x44ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17980
movq -0x20(%rbp), %rdi
movl %eax, %edx
leaq 0x1e96f(%rip), %rsi     # 0x36575
movb $0x0, %al
callq 0x4190
jmp 0x17c7e
movl $0x28, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl 0x3d968(%rip), %ecx     # 0x555a0
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17a00
movq 0x3d93d(%rip), %rcx     # 0x555a8
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3d92a(%rip)     # 0x555a8
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: ax_proposition
void
ax_proposition(FILE *fd, Ax_Props *p)
{
	if (p->t == 0)
	{	fprintf(fd, "c_code {	/* assert_r */\n");
		fprintf(fd, "	int _nq%d_(void) { return !(%s); }\n",
			p->nr, p->terms[0]);
		fprintf(fd, "	int _q%d_(void) { return (%s); }\n}\n",
			p->nr, p->terms[0]);
	} else
	{	fprintf(fd, "c_code {	/* assert_p */\n");
		fprintf(fd, "	int _q%d_(void) { return (%s); }\n",
			p->nr, p->terms[0]);
		fprintf(fd, "	int _r%d_(void) { return (%s); }\n}\n",
			p->nr, p->terms[1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x17cff
movq -0x8(%rbp), %rdi
leaq 0x1e8d3(%rip), %rsi     # 0x36587
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x1e8cb(%rip), %rsi     # 0x365a0
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x1e8cf(%rip), %rsi     # 0x365c5
movb $0x0, %al
callq 0x4190
jmp 0x17d53
movq -0x8(%rbp), %rdi
leaq 0x1e8e0(%rip), %rsi     # 0x365ea
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x1e8d8(%rip), %rsi     # 0x36603
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x1e8da(%rip), %rsi     # 0x36626
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/xtract.c
// Function: ax_fixed
void
ax_fixed(FILE *fd)
{
	fprintf(fd, "bool _ax_runs;\n");
	fprintf(fd, "c_code {\n");
	fprintf(fd, "	int (*_ax_q)(void), (*_ax_r)(void);\n\n");
	fprintf(fd, "	void _ax_start(int (*q)(void), int (*r)(void))\n");
	fprintf(fd, "	{	_ax_q = q;\n");
	fprintf(fd, "		_ax_r = r;\n");
	fprintf(fd, "		now._ax_runs = 1;\n");
	fprintf(fd, "}	}\n\n");
	fprintf(fd, "never {\n");
	fprintf(fd, "start:	/* assert_p(q,r) or ![](p -> (q U r)) */\n");
	fprintf(fd, "	do\n");
	fprintf(fd, "	:: c_expr { now._ax_runs && !_ax_r() } -> break\n");
	fprintf(fd, "	:: else\n");
	fprintf(fd, "	od;\n");
	fprintf(fd, "accept:\n");
	fprintf(fd, "	do\n");
	fprintf(fd, "	:: c_expr {  _ax_r() } -> _ax_runs = 0; goto start\n");
	fprintf(fd, "	:: c_expr { !_ax_r() && !_ax_q() } -> break	/* safety */\n");
	fprintf(fd, "	:: else						/* liveness */\n");
	fprintf(fd, "	od\n");
	fprintf(fd, "}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1e8d4(%rip), %rsi     # 0x3664b
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1d8d4(%rip), %rsi     # 0x3565d
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8c0(%rip), %rsi     # 0x3665b
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8d5(%rip), %rsi     # 0x36682
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8f4(%rip), %rsi     # 0x366b3
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8f1(%rip), %rsi     # 0x366c2
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8ed(%rip), %rsi     # 0x366d0
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8f0(%rip), %rsi     # 0x366e5
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8e4(%rip), %rsi     # 0x366eb
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8db(%rip), %rsi     # 0x366f4
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8fa(%rip), %rsi     # 0x36725
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8ed(%rip), %rsi     # 0x3672a
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e90d(%rip), %rsi     # 0x3675c
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e905(%rip), %rsi     # 0x36766
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8f9(%rip), %rsi     # 0x3676c
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8a0(%rip), %rsi     # 0x36725
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e8de(%rip), %rsi     # 0x36775
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e901(%rip), %rsi     # 0x367aa
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e92a(%rip), %rsi     # 0x367e5
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1e936(%rip), %rsi     # 0x36803
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
leaq 0x1f1db(%rip), %rsi     # 0x370ba
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/xtract.c
// Function: ax_decorate
static void
ax_decorate(scopetab_t *that, treenode *n)	/* set n->syment on all TN_IDENT leafs */
{	leafnode *m;

	if (!n) return;

	if (n->hdr.type != TN_IDENT)
	{	ax_decorate(that, n->lnode);
		ax_decorate(that, n->rnode);
	}
	m = (leafnode *) n;

	if (m->hdr.which == LEAF_T
	&&  m->hdr.type  == TN_IDENT)
	{	symentry_t *old = m->syment;

		m->syment = find_glob_symentry(that, m->data.sval->str);

		if (!old)
		{	printf("old symentry not set\n");
same:			printf("new:\t%s symtable entry for glob::%s\n",
				m->syment?"found":"missing",
				m->data.sval->str);
		} else if (m->syment != old)
		{	printf("new symentry differs from old:\n");
			printf("old:\t%s symtable entry for glob::%s\n",
				m->syment?"found":"missing",
				m->data.sval->str);
			goto same;
		} else
		{	printf("old and new both set and equal\n");
			goto same;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17f0c
jmp 0x18044
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
je 0x17f38
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x17ef0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x17ef0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x18044
movq -0x18(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x18044
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x5550
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x17fd6
leaq 0x1f752(%rip), %rdi     # 0x376e7
movb $0x0, %al
callq 0x4120
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x1f777(%rip), %rsi     # 0x37722
leaq 0x22c4a(%rip), %rax     # 0x3abfc
cmpq $0x0, %rcx
cmovneq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x1f730(%rip), %rdi     # 0x376fd
movb $0x0, %al
callq 0x4120
jmp 0x18042
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x1802f
leaq 0x1f73f(%rip), %rdi     # 0x3772a
movb $0x0, %al
callq 0x4120
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x1f721(%rip), %rsi     # 0x37722
leaq 0x22bf4(%rip), %rax     # 0x3abfc
cmpq $0x0, %rcx
cmovneq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x1f727(%rip), %rdi     # 0x3774a
movb $0x0, %al
callq 0x4120
jmp 0x17f9c
leaq 0x1f739(%rip), %rdi     # 0x3776f
movb $0x0, %al
callq 0x4120
jmp 0x17f9c
jmp 0x18044
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: x_hashtab
void
x_hashtab(hashtab_t *that, FILE *fpp)
{	symentry_t *list;
	int j;

	for (j = 0; j < that->tsize; j++)
	for (list = that->tab[j]; list; list = list->next)
		x_frag(list->node, fpp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x180b9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x180ac
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x16cb0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18086
jmp 0x180ae
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18067
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: strip_pthread_fct
static void
strip_pthread_fct(char *what)
{	char *q, *r, *s, *t;

	q = t = strstr(OutBuf, what);
	if (!q) return;

	q += strlen(what);
	r = strrchr(q, ')');
	if (!r) return;

	for (s = t; s <= r; s++)
	{	*s = ' ';	// erase the fct call
	}
	*t = '0';
	// in the model no error is returned from pthread_create or pthread_join

	// sample result in OutBuf at this point: "C: (0!=(Pmain->err=0"
	// the original condition had a call to 'what()' inside this condition
	// the 'what()' call was moved outside the condition
	//
	// we replace the removed function call with 0, meaning non-failure
	// if the original condition had an embedded assignment of the result
	// we need to remove that side-effect as well (hoping that the variable
	// assigned zero does not get reused somewhere later -- this is a hack

	// look if there was an assignment operator directly before 'what()'
	fix_side_effect(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x30179(%rip), %rdi     # 0x48550
callq 0x4280
movq %rax, -0x28(%rbp)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x183ed
jmp 0x18450
movq -0x8(%rbp), %rdi
callq 0x40f0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x4130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18419
jmp 0x18450
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x18440
movq -0x20(%rbp), %rax
movb $0x20, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x18421
movq -0x28(%rbp), %rax
movb $0x30, (%rax)
movq -0x28(%rbp), %rdi
callq 0x18c90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: replace_pthread_join
static void
replace_pthread_join(void)
{	char *q, *r;

	q = strstr(OutBuf, "pthread_join(");
	if (!q) return;

	r = q + strlen("pthread_join(");
	// keep the arguments
	// and make this a blocking statement
	fprintf(fp, "	c_expr { spin_join(%s }\n", r);

	strip_pthread_fct("pthread_join(");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x300e1(%rip), %rdi     # 0x48550
leaq 0x1e67c(%rip), %rsi     # 0x36af2
callq 0x4280
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x18488
jmp 0x184b9
movq -0x8(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x10(%rbp)
movq 0x300a5(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
leaq 0x1ec95(%rip), %rsi     # 0x3713b
movb $0x0, %al
callq 0x4190
leaq 0x1e63e(%rip), %rdi     # 0x36af2
callq 0x183c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: thread_has_params
static int
thread_has_params(char *s)
{	Fcts *g;

	for (g = modex_locals; g; g = g->nxt)
	{	if (strcmp(g->tg, s) == 0
		&&  g->fc == 2)
		{	return 1;
	}	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3196d(%rip), %rax     # 0x4a5a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18c77
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x18c67
movq -0x18(%rbp), %rax
cmpl $0x2, 0x30(%rax)
jne 0x18c67
movl $0x1, -0x4(%rbp)
jmp 0x18c7e
jmp 0x18c69
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18c37
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/xtract.c
// Function: fix_side_effect
static void
fix_side_effect(char *t)
{
	do {	--t;
		if (*t != ' ' && *t != '\t')
		{	break;
		}
	} while (t > OutBuf);

	if (*t == '=' && t > OutBuf && isalnum((int)*(t-1)))	// found it
	{	int n, m = 0;
		for (n = 0; n < strlen(OutBuf); n++)
		{	if (OutBuf[n] == '(')
			{	m++;
			} else if (OutBuf[n] == ')')
			{	m--;
		}	}
		strcpy(OutBuf, "C: ");
		while (m-- > 0)
		{	strcat(OutBuf, "(");
		}
		strcat(OutBuf, "0");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x18cc2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x18cc2
jmp 0x18cd1
jmp 0x18cc4
leaq 0x2f885(%rip), %rax     # 0x48550
cmpq %rax, -0x8(%rbp)
ja 0x18c9c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x18dd9
leaq 0x2f868(%rip), %rax     # 0x48550
cmpq %rax, -0x8(%rbp)
jbe 0x18dd9
callq 0x4290
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x18dd9
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2f81e(%rip), %rdi     # 0x48550
callq 0x40f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x18d8e
movslq -0xc(%rbp), %rcx
leaq 0x2f802(%rip), %rax     # 0x48550
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x18d62
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18d81
movslq -0xc(%rbp), %rcx
leaq 0x2f7e3(%rip), %rax     # 0x48550
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x18d7f
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18d81
jmp 0x18d83
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18d23
leaq 0x2f7bb(%rip), %rdi     # 0x48550
leaq 0x1c4a0(%rip), %rsi     # 0x3523c
callq 0x40a0
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jle 0x18dc6
leaq 0x2f798(%rip), %rdi     # 0x48550
leaq 0x2619d(%rip), %rsi     # 0x3ef5c
callq 0x4250
jmp 0x18da1
leaq 0x2f783(%rip), %rdi     # 0x48550
leaq 0x1e4a6(%rip), %rsi     # 0x3727a
callq 0x4250
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: setup_fct_call
static void
setup_fct_call(treenode *root, char *s)
{
	if (dynamic)
	{	fprintf(fp, "\n\n\trun p_%s();", s);
	}
	fprintf(fp, "\n\n\tatomic {\n");
	fprintf(fp, "\t\tlck_p_%s == 0 && empty(req_cll_p_%s) -> ", s, s); 
	fprintf(fp, "req_cll_p_%s!_pid; /* req to call */\n", s);
	fct_params(root->lnode, root->rnode);	/* set params */
	fprintf(fp, "\t\texc_cll_p_%s!_pid; /* start call */\n", s);
	fprintf(fp, "\t}\n"); /* end of atomic */
	fprintf(fp, "\tret_p_%s?eval(_pid);\n\n\t", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2ee09(%rip), %rax     # 0x47c00
cmpl $0x0, (%rax)
je 0x18e15
movq 0x2f73d(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
leaq 0x1e4dc(%rip), %rsi     # 0x372ea
movb $0x0, %al
callq 0x4190
movq 0x2f724(%rip), %rdi     # 0x48540
leaq 0x1e4d6(%rip), %rsi     # 0x372f9
movb $0x0, %al
callq 0x4190
movq 0x2f70f(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1e4c6(%rip), %rsi     # 0x37306
movb $0x0, %al
callq 0x4190
movq 0x2f6f2(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
leaq 0x1e4d8(%rip), %rsi     # 0x37331
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x18ed0
movq 0x2f6c4(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
leaq 0x1e4d0(%rip), %rsi     # 0x37357
movb $0x0, %al
callq 0x4190
movq 0x2f6ab(%rip), %rdi     # 0x48540
leaq 0x1e21d(%rip), %rsi     # 0x370b9
movb $0x0, %al
callq 0x4190
movq 0x2f696(%rip), %rdi     # 0x48540
movq -0x10(%rbp), %rdx
leaq 0x1e4c9(%rip), %rsi     # 0x3737e
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/xtract.c
// Function: fct_params
static void
fct_params(treenode *fct, treenode *pars)
{
	if (!fct || !pars || !visu) return;

	switch (pars->hdr.which) {
	case NODE_T:
		switch (pars->hdr.type) {
		case TN_PARAM_LIST:
		case TN_EXPR_LIST:
			fct_params(fct, pars->lnode);
			if (pars->rnode)
			{	fct_params(fct, pars->rnode);
			}
			break;
		default:
			goto A;
		}
		break;
	default:
A:		fprintf(fp, "\t\tc_code { now.par%d_", par_cnt++);
		print_tree(fct, fp);
		fprintf(fp, " = ");
#if 1
		strcpy(AltBuf, OutBuf);
		strcpy(OutBuf, "");
		modex_recur(pars);
		fprintf(fp, "%s", OutBuf);	// fct_params()
		strcpy(OutBuf, AltBuf);
		strcpy(AltBuf, "-x-x-");
#else
		if (((leafnode *) pars)->hdr.type == TN_IDENT)
		{	strcpy(AltBuf, OutBuf);
			strcpy(OutBuf, "");
			do_prefix((leafnode *)pars);
			fprintf(fp, OutBuf);	// fct_params()
			strcpy(OutBuf, AltBuf);
			strcpy(AltBuf, "-x-x-");
		}
		print_recur(pars, fp);
#endif
		fprintf(fp, "; };\n");
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18efa
cmpq $0x0, -0x10(%rbp)
je 0x18efa
leaq 0x2ecab(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x18eff
jmp 0x19026
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x4, %eax
jne 0x18f53
jmp 0x18f0c
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
orl $0x4, %eax
subl $0xe, %eax
je 0x18f1d
jmp 0x18f4c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x18ed0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x18f4a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x18ed0
jmp 0x18f4e
jmp 0x18f55
jmp 0x19026
jmp 0x18f55
movq 0x2f5e4(%rip), %rdi     # 0x48540
movl 0x3e066(%rip), %edx     # 0x56fc8
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3e05b(%rip)     # 0x56fc8
leaq 0x1e423(%rip), %rsi     # 0x37397
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rdi
movq 0x2f5ba(%rip), %rsi     # 0x48540
callq 0x31780
movq 0x2f5ae(%rip), %rdi     # 0x48540
leaq 0x258d1(%rip), %rsi     # 0x3e86a
movb $0x0, %al
callq 0x4190
leaq 0x35d19(%rip), %rdi     # 0x4ecc0
leaq 0x2f5a2(%rip), %rsi     # 0x48550
callq 0x40a0
leaq 0x2f596(%rip), %rdi     # 0x48550
leaq 0x1e4fd(%rip), %rsi     # 0x374be
callq 0x40a0
movq -0x10(%rbp), %rdi
callq 0xadb0
movq 0x2f56a(%rip), %rdi     # 0x48540
leaq 0x1c7e4(%rip), %rsi     # 0x357c1
leaq 0x2f56c(%rip), %rdx     # 0x48550
movb $0x0, %al
callq 0x4190
leaq 0x2f55e(%rip), %rdi     # 0x48550
leaq 0x35cc7(%rip), %rsi     # 0x4ecc0
callq 0x40a0
leaq 0x35cbb(%rip), %rdi     # 0x4ecc0
leaq 0x1e3a1(%rip), %rsi     # 0x373ad
callq 0x40a0
movq 0x2f528(%rip), %rdi     # 0x48540
leaq 0x1e0d7(%rip), %rsi     # 0x370f6
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/xtract.c
// Function: handle_neg
static void
handle_neg(treenode *n, char *oO, char *suff, treenode *m, int tabs, char *closing)
{	static char oA[1024];

	if (strlen(oO) == 0)
	{	wasfalse = 1;
		goto more;
	}
	map_neg(n, oO);
	vis_direct("\n");

	if (wastrue)
	{	strcpy(oA, OutBuf);	/* save */
		vis_start();
		vis_print("C: ");
		vis_print(oO);
		owf = wasfalse;
		owe = waselse;
		owt = wastrue;
		owh = ishidden;
		vis_lookup(ZN);	/* peek back */
		if (wasfalse)	/* no need to print guard */
		{	vis_start();
			vis_indent(tabs, ":: /* true */ ");
			vis_direct(suff);
			goto more;
		}
		/* else restore */
		strcpy(OutBuf, oA);
		wasfalse = owf;
		waselse  = owe;
		wastrue  = owt;
		ishidden = owh;
	}
	if (!wasfalse)
	{	vis_indent(tabs, ":: ");
		vis_flush(n);
		vis_direct(suff);
	}
more:
	vis_start();
	if (m && !wasfalse)
		modex_any(m, tabs+1);	/* an else leg */

	vis_indent(tabs, closing);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
cmpq $0x0, %rax
jne 0x1964e
movl $0x1, 0x3767b(%rip)     # 0x50cc4
jmp 0x19771
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19860
leaq 0x1c3f5(%rip), %rdi     # 0x35a57
callq 0x10b40
cmpl $0x0, 0x3ad26(%rip)     # 0x54394
je 0x19745
leaq 0x3dd75(%rip), %rdi     # 0x573f0
leaq 0x2eece(%rip), %rsi     # 0x48550
callq 0x40a0
callq 0x141b0
leaq 0x1bba9(%rip), %rdi     # 0x3523c
callq 0x15790
movq -0x10(%rbp), %rdi
callq 0x15790
movl 0x3761d(%rip), %eax     # 0x50cc4
movl %eax, 0x3acdf(%rip)     # 0x5438c
movl 0x37615(%rip), %eax     # 0x50cc8
movl %eax, 0x3dd27(%rip)     # 0x573e0
movl 0x3acd5(%rip), %eax     # 0x54394
movl %eax, 0x3acc3(%rip)     # 0x54388
movl 0x375f5(%rip), %eax     # 0x50cc0
movl %eax, 0x3acb3(%rip)     # 0x54384
xorl %eax, %eax
movl %eax, %edi
callq 0x149d0
cmpl $0x0, 0x375e3(%rip)     # 0x50cc4
je 0x19702
callq 0x141b0
movl -0x24(%rbp), %edi
leaq 0x1dd85(%rip), %rsi     # 0x37477
callq 0x15880
movq -0x18(%rbp), %rdi
callq 0x10b40
jmp 0x19771
leaq 0x2ee47(%rip), %rdi     # 0x48550
leaq 0x3dce0(%rip), %rsi     # 0x573f0
callq 0x40a0
movl 0x3ac71(%rip), %eax     # 0x5438c
movl %eax, 0x375a3(%rip)     # 0x50cc4
movl 0x3dcb9(%rip), %eax     # 0x573e0
movl %eax, 0x3759b(%rip)     # 0x50cc8
movl 0x3ac55(%rip), %eax     # 0x54388
movl %eax, 0x3ac5b(%rip)     # 0x54394
movl 0x3ac45(%rip), %eax     # 0x54384
movl %eax, 0x3757b(%rip)     # 0x50cc0
cmpl $0x0, 0x37578(%rip)     # 0x50cc4
jne 0x1976f
movl -0x24(%rbp), %edi
leaq 0x1dcd9(%rip), %rsi     # 0x37431
callq 0x15880
movq -0x8(%rbp), %rdi
callq 0x15110
movq -0x18(%rbp), %rdi
callq 0x10b40
jmp 0x19771
callq 0x141b0
cmpq $0x0, -0x20(%rbp)
je 0x19795
cmpl $0x0, 0x37540(%rip)     # 0x50cc4
jne 0x19795
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
callq 0x15ad0
movl -0x24(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x15880
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: handle_shortcut
static void
handle_shortcut(treenode *n, char *oO, treenode *m, int tabs)
{	/* the positive if cond mapped to false */

	vis_start();
	if (strlen(oO) == 0)
		return;	/* don't print anything */

	map_neg(n, oO);
	if (wastrue || waselse)	/* no need for guard */
	{	vis_start();
		modex_any(m, tabs);
	} else if (wasfalse)
	{	vis_start(); /* null if/do */
	} else
	{	vis_indent(tabs, "");
		vis_flush(m);	/* print guard */
		vis_direct("\n");
		modex_any(m, tabs);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x141b0
movq -0x10(%rbp), %rdi
callq 0x40f0
cmpq $0x0, %rax
jne 0x197dd
jmp 0x19851
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19860
cmpl $0x0, 0x3aba3(%rip)     # 0x54394
jne 0x197fc
cmpl $0x0, 0x374ce(%rip)     # 0x50cc8
je 0x1980f
callq 0x141b0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15ad0
jmp 0x19851
cmpl $0x0, 0x374ae(%rip)     # 0x50cc4
je 0x1981f
callq 0x141b0
jmp 0x1984f
movl -0x1c(%rbp), %edi
leaq 0x1dc95(%rip), %rsi     # 0x374be
callq 0x15880
movq -0x18(%rbp), %rdi
callq 0x15110
leaq 0x1c219(%rip), %rdi     # 0x35a57
callq 0x10b40
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15ad0
jmp 0x19851
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: map_neg
static char *
map_neg(treenode *n, char *oO)
{	char *p;

	vis_start();
	vis_print("C: !");
	vis_print(oO);

	owf = wasfalse;
	owt = wastrue;
	owe = waselse;
	owh = ishidden;
	if (!strstr(oO, ND_CHOICE))
		PosElse = 1;
	p = vis_lookup(n);		/* map */
	PosElse = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x141b0
leaq 0x1c722(%rip), %rdi     # 0x35f9e
callq 0x15790
movq -0x10(%rbp), %rdi
callq 0x15790
movl 0x37434(%rip), %eax     # 0x50cc4
movl %eax, 0x3aaf6(%rip)     # 0x5438c
movl 0x3aaf8(%rip), %eax     # 0x54394
movl %eax, 0x3aae6(%rip)     # 0x54388
movl 0x37420(%rip), %eax     # 0x50cc8
movl %eax, 0x3db32(%rip)     # 0x573e0
movl 0x3740c(%rip), %eax     # 0x50cc0
movl %eax, 0x3aaca(%rip)     # 0x54384
movq -0x10(%rbp), %rdi
leaq 0x1d565(%rip), %rsi     # 0x36e2a
callq 0x4280
cmpq $0x0, %rax
jne 0x198da
movl $0x1, 0x353d6(%rip)     # 0x4ecb0
movq -0x8(%rbp), %rdi
callq 0x149d0
movq %rax, -0x18(%rbp)
movl $0x0, 0x353bf(%rip)     # 0x4ecb0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: make_if
if_node *
make_if(tn_t type)
{
    if_node *tmp_node;

    tmp_node = (if_node *) HeapAlloc(Parse_TOS->node_heap);
    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_if.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = IF_T;
    tmp_node->hdr.type  = type;
    tmp_node->hdr.defuse = 0;
    tmp_node->cond  = (treenode *) NULL;
    tmp_node->then_n = (treenode *) NULL;
    tmp_node->else_n = (treenode *) NULL;
    return tmp_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c826(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b3e9
movq 0x29c28(%rip), %rax     # 0x44ff8
movq (%rax), %rsi
leaq 0x1c9f9(%rip), %rdi     # 0x37dd3
callq 0x4150
movl $0x1, %edi
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: make_for
for_node *
make_for(tn_t type)
{
    for_node *tmp_node;

    tmp_node = (for_node *) HeapAlloc(Parse_TOS->node_heap);

    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_for.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = FOR_T;
    tmp_node->hdr.type = type;
    tmp_node->hdr.defuse = 0;
    tmp_node->init = (treenode *) NULL;
    tmp_node->test = (treenode *) NULL;
    tmp_node->incr = (treenode *) NULL;
    tmp_node->stemnt = (treenode *) NULL;
    return tmp_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c786(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b489
movq 0x29b88(%rip), %rax     # 0x44ff8
movq (%rax), %rsi
leaq 0x1c97b(%rip), %rdi     # 0x37df5
callq 0x4150
movl $0x1, %edi
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: make_leaf
leafnode *
make_leaf(tn_t type)
{
    leafnode *tmp_node;

    tmp_node = (leafnode *) HeapAlloc(Parse_TOS->node_heap);

    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_leaf.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = LEAF_T;
    tmp_node->hdr.type = type;
    tmp_node->hdr.defuse = 0;

    tmp_node->syment = (symentry_t *) NULL;
    return tmp_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c6d6(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b539
movq 0x29ad8(%rip), %rax     # 0x44ff8
movq (%rax), %rsi
leaq 0x1c8ee(%rip), %rdi     # 0x37e18
callq 0x4150
movl $0x1, %edi
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: make_node
treenode *
make_node(tn_t type)
{
    treenode *tmp_node;

    tmp_node = (treenode *) HeapAlloc(Parse_TOS->node_heap);

    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_node.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = NODE_T;
    tmp_node->hdr.type  = type;
    tmp_node->hdr.defuse = 0;

    tmp_node->lnode = (treenode *) NULL;
    tmp_node->rnode = (treenode *) NULL;
    tmp_node->syment = (symentry_t *) NULL;

    return tmp_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2c656(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b5b9
movq 0x29a58(%rip), %rax     # 0x44ff8
movq (%rax), %rsi
leaq 0x1c892(%rip), %rdi     # 0x37e3c
callq 0x4150
movl $0x1, %edi
callq 0x4270
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: free_tree
void
free_tree(treenode *root)
{
    leafnode *leaf;
    if_node  *ifn;
    for_node *forn;

    if (!root)
        return;

    switch (root->hdr.which){

    case LEAF_T:
        leaf = (leafnode *) root;
        if (leaf->hdr.tok == STRING)
           e_free(leaf->data.str);
        break;

    case NODE_T:
        free_tree(root->lnode);
        free_tree(root->rnode);
        break;

    case IF_T:
        ifn = (if_node *) root;
        free_tree(ifn->cond);
        free_tree(ifn->then_n);
        free_tree(ifn->else_n);
        break;

    case FOR_T:
        forn = (for_node *) root;
        free_tree(forn->init);
        free_tree(forn->test);
        free_tree(forn->incr);
        free_tree(forn->stemnt);
        break;

    default:
    case NONE_T:
        break;
    }

    HeapFree(Parse_TOS->node_heap,root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1b628
jmp 0x1b71d
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x1b702
movq -0x28(%rbp), %rax
leaq 0x1c4d5(%rip), %rcx     # 0x37b1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x103, 0x18(%rax)      # imm = 0x103
jne 0x1b672
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4a60
jmp 0x1b706
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1b610
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1b610
jmp 0x1b706
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1b610
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1b610
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1b610
jmp 0x1b706
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1b610
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1b610
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1b610
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1b610
jmp 0x1b706
jmp 0x1b704
jmp 0x1b706
leaq 0x2c4cb(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: name_of_nodetype
char*
name_of_nodetype(node_type val)
{
    switch (val)
    {
    case NONE_T:
        return SHOW(NONE_T);
    case LEAF_T:
        return SHOW(LEAF_T);
    case IF_T:
        return SHOW(IF_T);
    case FOR_T:
        return SHOW(FOR_T);
    case NODE_T:
        return SHOW(NODE_T);
    default:
        return "<Unknown Node Type>";
    }

#undef SHOW
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x1ba29
movq -0x18(%rbp), %rax
leaq 0x1c165(%rip), %rcx     # 0x37b44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c990(%rip), %rax     # 0x3837f
movq %rax, -0x8(%rbp)
jmp 0x1ba34
leaq 0x1c98a(%rip), %rax     # 0x38386
movq %rax, -0x8(%rbp)
jmp 0x1ba34
leaq 0x1c984(%rip), %rax     # 0x3838d
movq %rax, -0x8(%rbp)
jmp 0x1ba34
leaq 0x1c97c(%rip), %rax     # 0x38392
movq %rax, -0x8(%rbp)
jmp 0x1ba34
leaq 0x1c975(%rip), %rax     # 0x38398
movq %rax, -0x8(%rbp)
jmp 0x1ba34
leaq 0x1c96f(%rip), %rax     # 0x3839f
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/tree.c
// Function: find_func_name
leafnode *
find_func_name(treenode *n)
{
	while (n && (n->hdr.which != LEAF_T))
	{	switch(n->hdr.which) {
		case NODE_T:
			switch(n->hdr.type) {
			case TN_DECL:
				n = n->rnode;
				break;
			case TN_FUNC_DECL:
				n = n->lnode;
				break;
			default:
				goto bad;
			}
			break;
		case FOR_T:
			if (n->hdr.type == TN_FUNC_DEF)
				n = ((for_node *) n)->test;
			break;
		default:
bad:			fprintf(stderr,
				"%s: error: bad node in find_func_name;\n"
				"	node: %s, type: %s\n",
				progname, name_of_nodetype(n->hdr.which),
				name_of_node(n->hdr.type));
			n = NULL;
			break;
	}	}

	return (leafnode*) n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x1c1a5
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1c1b1
jmp 0x1c281
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x3, %eax
je 0x1c206
jmp 0x1c1c1
movl -0x10(%rbp), %eax
subl $0x4, %eax
jne 0x1c21e
jmp 0x1c1cb
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x1c1f4
jmp 0x1c1dc
movl -0x14(%rbp), %eax
subl $0x5, %eax
jne 0x1c202
jmp 0x1c1e6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c204
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c204
jmp 0x1c220
jmp 0x1c27c
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x1c21c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c27c
jmp 0x1c220
movq 0x28dd1(%rip), %rax     # 0x44ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x28f3b(%rip), %rax     # 0x45170
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1b9c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1bc40
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rax, %r8
leaq 0x1bdbe(%rip), %rsi     # 0x3802b
movb $0x0, %al
callq 0x4190
movq $0x0, -0x8(%rbp)
jmp 0x1c18c
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: new_stk_item
Stk_Item  *
new_stk_item( FILE *fp, char *fname )
{
    Stk_Item *stk_item;

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

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

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

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

    stk_item->yyin     = fp;

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

    stk_item->parse_tree = (treenode *) NULL;

    stk_item->next = (Stk_Item *) NULL;

    return(stk_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x3b1c8(%rip)     # 0x57820
je 0x1c689
movq 0x3b1bf(%rip), %rax     # 0x57820
movq %rax, -0x20(%rbp)
movq 0x3b1b4(%rip), %rax     # 0x57820
movq 0x38(%rax), %rax
movq %rax, 0x3b1a9(%rip)     # 0x57820
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4160
jmp 0x1c697
movl $0x40, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x40a0
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x27810
movq -0x20(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x1c706
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4a60
movq -0x20(%rbp), %rdi
callq 0x4a60
movq $0x0, -0x8(%rbp)
jmp 0x1c799
movl $0x50, %edi
xorl %esi, %esi
callq 0x43a0
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1c74d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4a60
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x285c0
movq -0x20(%rbp), %rdi
callq 0x4a60
movq $0x0, -0x8(%rbp)
jmp 0x1c799
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: new_treestk
TreeStack *
new_treestk(void)
{	TreeStack *treestk;

	treestk = (TreeStack *) e_malloc(sizeof(TreeStack));
	treestk->top    = NULL;
	treestk->bottom = NULL;

	treestk->contxt = NULL;
	return treestk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 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/treestk.c
// Function: push
void
push(TreeStack *treestk, Stk_Item *stk_item )
{
    if (! treestk || ! stk_item)
        return;

    stk_item->next = treestk->top;

    if (! treestk->top)
        treestk->bottom = stk_item;

    treestk->top = stk_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c87a
cmpq $0x0, -0x10(%rbp)
jne 0x1c87c
jmp 0x1c8ac
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c8a1
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: pop
Stk_Item *
pop(TreeStack *treestk)
{
    Stk_Item *stk_item, *nxt_item;

    if (is_empty(treestk))
        return((Stk_Item *) NULL);

    stk_item = treestk->top;
    nxt_item = treestk->top->next;

    if (! nxt_item)
        treestk->bottom = (Stk_Item *) NULL;

    treestk->top = nxt_item;

    return(stk_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c920
cmpl $0x0, %eax
je 0x1c8d4
movq $0x0, -0x8(%rbp)
jmp 0x1c914
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1c901
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/treestk.c
// Function: reset_position
void
reset_position(TreeStack *treestk)
{
    if ( !(Parse_TOS = top_of_stack(treestk)))
        return;

    yy_switch_to_buffer(Parse_TOS->yybuff);
    yyin = top_file(treestk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c950
leaq 0x2b1ec(%rip), %rcx     # 0x47bd8
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1c9f7
jmp 0x1ca20
leaq 0x2b1da(%rip), %rax     # 0x47bd8
movq (%rax), %rax
movq 0x30(%rax), %rdi
callq 0x284b0
movq -0x8(%rbp), %rdi
callq 0x1c990
movq %rax, %rcx
leaq 0x3ae13(%rip), %rax     # 0x57830
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)