LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: x_frag
void
x_frag(treenode *root, FILE *fd)
{	FILE *ofp = fp;

	if (!root
	||  root->hdr.type == TN_FUNC_DEF
	||  root->hdr.type == TN_FOR)	/* was FOR_T */
		return;

	fp = fd;
	ByPass = 1;	/* bypass the lookup table */
	decl_cnt = 1;

	vis_start();
	modex_recur(root);

	if (root->hdr.line >= 0
	&&  strlen(OutBuf) > 0
	&&  (strstr(OutBuf, "enum ") || strstr(OutBuf, "struct ")))	/* reason? */
	{	cleanse(OutBuf);
		/* fprintf(stderr, "x_frag OutBuf=<%s> want=<%s>\n", OutBuf, want); */
		if (imported(OutBuf, want, 1))
		{	if (du_mode)	/* -defuse */
			{	char *yy, *y = OutBuf;
				while (*y == '*' || *y == ' ' || *y == '\t')
				{	y++;
				}
				if ((yy = strstr(y, "[]")) != NULL)
				{	*yy = '\0';
				}
				fprintf(fp, "int %s; /* Local to %s from symtab */\n",
					y, want);
			} else
			{	if (!strchr(OutBuf, '='))	// should prevent this
				fprintf(fp, "c_state \"%s\" \"Local %s\"\t/* from symtab */\n",
					OutBuf, want);
	}	}	}

	root->hdr.line = -root->hdr.line - 1;	/* mark visited */
	decl_cnt = 0;
	ByPass = 0;
	fp = ofp;
}

// Assembly:
testq %rdi, %rdi
je 0x123ad
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %eax
cmpl $0x1, %eax
je 0x123a2
cmpl $0x1e, %eax
je 0x123a2
movq 0x250f5(%rip), %r15     # 0x37370
movq %rsi, 0x250ee(%rip)     # 0x37370
movb $0x1, 0x2ea87(%rip)     # 0x40d10
movl $0x1, 0x2f6cd(%rip)     # 0x41960
movb $0x0, 0x250e6(%rip)     # 0x37380
movq %rbx, %rdi
callq 0x8cbf
cmpl $0x0, 0x10(%rbx)
js 0x1238a
cmpb $0x0, 0x250cd(%rip)     # 0x37380
je 0x1238a
leaq 0x250c0(%rip), %rdi     # 0x37380
leaq 0x10a4a(%rip), %rsi     # 0x22d11
callq 0x42d0
testq %rax, %rax
jne 0x122ed
leaq 0x250a8(%rip), %rdi     # 0x37380
leaq 0x10a38(%rip), %rsi     # 0x22d17
callq 0x42d0
testq %rax, %rax
je 0x1238a
leaq 0x2508c(%rip), %r14     # 0x37380
movq %r14, %rdi
callq 0xc831
leaq 0x21ea5(%rip), %r12     # 0x341a8
movq (%r12), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0xcaf8
testl %eax, %eax
je 0x1238a
leaq 0x2473b(%rip), %rax     # 0x36a58
cmpl $0x0, (%rax)
je 0x12376
movabsq $0x40100000200, %rax    # imm = 0x40100000200
movzbl (%r14), %ecx
cmpq $0x2a, %rcx
ja 0x12341
btq %rcx, %rax
jae 0x12341
incq %r14
jmp 0x1232c
leaq 0xddd7(%rip), %rsi      # 0x2011f
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
je 0x12358
movb $0x0, (%rax)
movq 0x25011(%rip), %rdi     # 0x37370
movq (%r12), %rcx
leaq 0x10b6a(%rip), %rsi     # 0x22ed4
movq %r14, %rdx
xorl %eax, %eax
callq 0x41c0
jmp 0x1238a
leaq 0x25003(%rip), %rdi     # 0x37380
pushq $0x3d
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x123ae
notl 0x10(%rbx)
andl $0x0, 0x2f5cc(%rip)     # 0x41960
movb $0x0, 0x2e975(%rip)     # 0x40d10
movq %r15, 0x24fce(%rip)     # 0x37370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x24fbb(%rip), %rdi     # 0x37370
movq (%r12), %rcx
leaq 0x10b3b(%rip), %rsi     # 0x22efb
leaq 0x24fb9(%rip), %rdx     # 0x37380
jmp 0x1236d
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: modex_leaf
void
modex_leaf(leafnode *leaf, int tabs)
{
	if (leaf == NULL || !visu) return;

	/* normally not called */
	linenr = leaf->hdr.line;
	vis_indent(tabs, "");

	switch(leaf->hdr.type){
	case TN_IDENT:	/* modex_leaf */
		vis_print(nmestr(leaf->data.sval));
		break;
	case TN_TYPE:
		if (Verbose&2)
		{	vis_print("Type ");
			vis_print(toksym(leaf->hdr.tok,0));
			if (leaf->hdr.tok == TYPEDEF_NAME)
			{	vis_print(" ");
				vis_print(nmestr(leaf->data.sval));
		}	}
		break;
	case TN_INT:
		vis_print("Int ");
		vis_print_d(leaf->data.ival);
		vis_print("\n");
		break;
	case TN_REAL:
		vis_print("Real ");
		vis_print_g(leaf->data.dval);
		vis_print("\n");
		break;
	case TN_STRING:
		if (0)
		fprintf(stderr, "STRING (%s) at line %3d\n",
			leaf->data.str, leaf->hdr.line);
		vis_print("\"");
		fputs_metastr(leaf->data.str);
		vis_print("\"");
		break;
	case TN_ELLIPSIS:
		vis_print("Ellipsis\n");
		break;
	case TN_LABEL:
		vis_print("Label\n");
		break;
	default:
		fprintf(stderr, "%s: error: unknown leaf type %d\n", progname, leaf->hdr.type);
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1249b
leaq 0x245fb(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0x1249b
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movl %eax, 0x2e922(%rip)     # 0x40d14
leaq 0x11b98(%rip), %rax     # 0x23f91
movl %esi, %edi
movq %rax, %rsi
callq 0x1079f
movl 0x1c(%rbx), %ecx
leal -0x22(%rcx), %eax
cmpl $0xf, %eax
ja 0x124eb
leaq 0xfa67(%rip), %rdx      # 0x21e80
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x10b18(%rip), %rdi     # 0x22f41
jmp 0x124df
leaq 0x197b0(%rip), %r14     # 0x2bbe5
movq %r14, %rdi
callq 0x106f2
movq 0x30(%rbx), %rdi
callq 0x118e4
movq %r14, %rdi
jmp 0x124df
leaq 0x24627(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
je 0x1249b
leaq 0x10ac5(%rip), %rdi     # 0x22f26
callq 0x106f2
movl 0x18(%rbx), %edi
xorl %esi, %esi
callq 0x13d8c
movq %rax, %rdi
callq 0x106f2
cmpl $0x105, 0x18(%rbx)      # imm = 0x105
jne 0x1249b
leaq 0x107d0(%rip), %rdi     # 0x22c58
callq 0x106f2
movq 0x30(%rbx), %rdi
callq 0x463c
movq %rax, %rdi
jmp 0x124df
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10a87(%rip), %rdi     # 0x22f31
callq 0x106f2
movsd 0x30(%rbx), %xmm0
callq 0x106b8
jmp 0x124d8
leaq 0x10a75(%rip), %rdi     # 0x22f37
jmp 0x124df
leaq 0x10a61(%rip), %rdi     # 0x22f2c
callq 0x106f2
movl 0x30(%rbx), %edi
callq 0x1067c
leaq 0x1018b(%rip), %rdi     # 0x2266a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x106f2
movq 0x21b06(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x21ca4(%rip), %rax     # 0x341a0
movq (%rax), %rdx
leaq 0x10a42(%rip), %rsi     # 0x22f48
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: modex_reset
void
modex_reset(void)
{
	if (Verbose_cmds)
	{	printf(" -- Modex Reset\n");
	}

	decl_cnt = in_call = in_args = is_label = 0;
	just_left_blk = enum_list_cnt = taboffset = 0;
	sawdefault = Down = 0;
	FreshLut = needreturn = sawreturn = 0;
	ByPass = PosElse = 0;
	extra_comment = owf = owt = owh = 0;
	debug = lastln = lastpb = pending = 0;
	ishidden = wasfalse = wastrue = waselse = nreturns = 0;
	linenr = do_level = sw_level = sw_first = 0;
	do_uniq = o_cnt = visu = 0;
	nblanks = with_decorations = 0;
	cache = comms = commstail = (Cache *) 0;
	fcts = maps = incls = (Fcts *) 0;
	prec = (PreC *) 0;
	decors = fdecors = (Decor *) 0;

	strcpy(fct_name, ":global:");
	strcpy(derscope, "");
	strcpy(dertype,  "");
	strcpy(dername,  "");
	strcpy(derproc,  "");
}

// Assembly:
pushq %rax
leaq 0x242d6(%rip), %rax     # 0x36a1c
cmpl $0x0, (%rax)
je 0x12757
leaq 0x11ab5(%rip), %rdi     # 0x24207
callq 0x40d0
andl $0x0, 0x26c62(%rip)     # 0x393c0
andl $0x0, 0x26c57(%rip)     # 0x393bc
andl $0x0, 0x26c4c(%rip)     # 0x393b8
andl $0x0, 0x2f1ed(%rip)     # 0x41960
andl $0x0, 0x2e5a2(%rip)     # 0x40d1c
andl $0x0, 0x30a2b(%rip)     # 0x431ac
andl $0x0, 0x26c08(%rip)     # 0x39390
andl $0x0, 0x30a15(%rip)     # 0x431a4
andl $0x0, 0x30a12(%rip)     # 0x431a8
andl $0x0, 0x30a13(%rip)     # 0x431b0
andl $0x0, 0x30a10(%rip)     # 0x431b4
andl $0x0, 0x30a0d(%rip)     # 0x431b8
andl $0x0, 0x301c2(%rip)     # 0x42974
andl $0x0, 0x301b7(%rip)     # 0x42970
andl $0x0, 0x309e0(%rip)     # 0x431a0
andl $0x0, 0x2d331(%rip)     # 0x3faf8
andl $0x0, 0x2d326(%rip)     # 0x3faf4
andl $0x0, 0x2d31b(%rip)     # 0x3faf0
andl $0x0, 0x2e954(%rip)     # 0x41130
andl $0x0, 0x2d51d(%rip)     # 0x3fd00
andl $0x0, 0x24b8e(%rip)     # 0x37378
andl $0x0, 0x2e523(%rip)     # 0x40d14
leaq 0x241e0(%rip), %rax     # 0x369d8
andl $0x0, (%rax)
andl $0x0, 0x2a296(%rip)     # 0x3ca98
andl $0x0, 0x2e517(%rip)     # 0x40d20
andl $0x0, 0x2a2b8(%rip)     # 0x3cac8
andq $0x0, 0x309a8(%rip)     # 0x431c0
andq $0x0, 0x2a2a0(%rip)     # 0x3cac0
andq $0x0, 0x2a290(%rip)     # 0x3cab8
xorl %eax, %eax
andq $0x0, 0x26b6e(%rip)     # 0x393a0
movb %al, 0x2e4e0(%rip)      # 0x40d18
andq $0x0, 0x26b68(%rip)     # 0x393a8
movb %al, 0x2a26e(%rip)      # 0x3cab4
andq $0x0, 0x26b4a(%rip)     # 0x39398
movb %al, 0x2b28c(%rip)      # 0x3dae0
andq $0x0, 0x2d4ac(%rip)     # 0x3fd08
movb %al, 0x2e4ae(%rip)      # 0x40d10
andq $0x0, 0x26b1e(%rip)     # 0x39388
movb %al, 0x2a260(%rip)      # 0x3cad0
andq $0x0, 0x26b08(%rip)     # 0x39380
movb %al, 0x26b5a(%rip)      # 0x393d8
movb %al, 0x21b14(%rip)      # 0x34398
movabsq $0x3a6c61626f6c673a, %rcx # imm = 0x3A6C61626F6C673A
movq %rcx, 0x21afb(%rip)     # 0x34390
movb %al, 0x2eea5(%rip)      # 0x41740
movb %al, 0x2ea9f(%rip)      # 0x41340
movb %al, 0x26b39(%rip)      # 0x393e0
movb %al, 0x2eeb3(%rip)      # 0x41760
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: alldone
void
alldone(void)
{
	if (fp)
	{
if (debug_io) fprintf(stderr, "close .. %p\n", fp);
		Fclose(fp);
fp = 0;
	}
}

// Assembly:
movq 0x24aba(%rip), %rdx     # 0x37370
testq %rdx, %rdx
je 0x128dc
pushq %rax
leaq 0x24155(%rip), %rax     # 0x36a18
cmpl $0x0, (%rax)
jne 0x128dd
movq %rdx, %rdi
callq 0x59e0
andq $0x0, 0x24a98(%rip)     # 0x37370
addq $0x8, %rsp
retq
movq 0x21714(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x106d5(%rip), %rsi     # 0x22fc3
xorl %eax, %eax
callq 0x41c0
movq 0x24a74(%rip), %rdx     # 0x37370
jmp 0x128c8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10478(%rip), %r15     # 0x2303e
leaq 0x1008a(%rip), %r12     # 0x22c57
testl %ebp, %ebp
movl $0x0, %r14d
cmovgl %ebp, %r14d
testq %rbx, %rbx
je 0x12c5c
leaq 0x10454(%rip), %rdi     # 0x23039
movl %edx, %esi
xorl %eax, %eax
callq 0x4140
subl $0x1, %r14d
jb 0x12c00
movq %r12, %rdi
xorl %eax, %eax
callq 0x4140
jmp 0x12bee
movl 0x18(%rbx), %edi
xorl %esi, %esi
callq 0x13d8c
movq %rax, %r13
movl (%rbx), %edi
callq 0x14527
movq %rax, %r14
movl 0x1c(%rbx), %edi
callq 0x1467f
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4140
cmpl $0x2d, 0x1c(%rbx)
je 0x12c6b
pushq $0xa
popq %rdi
callq 0x4050
movq 0x30(%rbx), %rdi
incl %ebp
movl %ebp, %esi
pushq $0x4c
popq %rdx
callq 0x12baf
movq 0x38(%rbx), %rbx
pushq $0x52
popq %rdx
jmp 0x12bcd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x103d0(%rip), %rdi     # 0x2304a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x12cce
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2d, 0x1c(%rdi)
je 0x12cc8
movq 0x30(%rbx), %rdi
callq 0x12c8f
movl %eax, %ebp
movq 0x38(%rbx), %rdi
callq 0x12c8f
movl %eax, %ecx
addl %ebp, %ecx
xorl %eax, %eax
cmpl $0x14c, 0x18(%rbx)      # imm = 0x14C
sete %al
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %r14, %r14
je 0x12cff
cmpl $0x14c, 0x18(%r14)      # imm = 0x14C
jne 0x12d09
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x12ccf
movq 0x38(%r14), %r14
jmp 0x12cde
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x10(%rbx)
je 0x12d1d
cmpq $0x0, 0x18(%rbx)
jne 0x12d7c
pushq $0x1
popq %r13
jmp 0x12d20
xorl %r13d, %r13d
leaq 0x306a9(%rip), %r15     # 0x433d0
leaq 0x24652(%rip), %r12     # 0x37380
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b0
movb $0x0, 0x24640(%rip)     # 0x37380
movq %r14, %rdi
callq 0x8cbf
movq %r12, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x10(%rbx,%r13,8)
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
movq %r12, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x40b0
movq 0x21275(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x21413(%rip), %rax     # 0x341a0
movq (%rax), %rdx
leaq 0x102ba(%rip), %rsi     # 0x23051
xorl %eax, %eax
callq 0x41c0
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x23cc6(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
je 0x12dc8
pushq $0x54
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12baf
cmpl $0x1, %ebp
ja 0x12e23
testq %rbx, %rbx
je 0x12e23
movq %rbx, %rdi
callq 0x12c8f
cmpl %ebp, %eax
jne 0x12e28
pushq $0x28
popq %rdi
callq 0x4739
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movl 0x315db(%rip), %eax     # 0x443d0
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12ccf
movq 0x315c5(%rip), %rax     # 0x443d8
movq %rax, 0x20(%r14)
movq %r14, 0x315ba(%rip)     # 0x443d8
popq %rbx
popq %r14
popq %rbp
retq
testq %rbx, %rbx
je 0x12e66
movq 0x211c9(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x21367(%rip), %rax     # 0x341a0
movq (%rax), %rdx
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %r8d
testl %ebp, %ebp
leaq 0x119c4(%rip), %rax     # 0x24811
leaq 0xfe47(%rip), %r9       # 0x22c9b
cmoveq %rax, %r9
leaq 0x1020f(%rip), %rsi     # 0x2306e
xorl %eax, %eax
callq 0x41c0
movq 0x2118b(%rip), %rax     # 0x33ff8
movq (%rax), %r14
movq %rbx, %rdi
callq 0x12c8f
leaq 0x1020d(%rip), %rsi     # 0x2308c
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x12edd
leaq 0x1025c(%rip), %rdi     # 0x23101
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x10258(%rip), %rsi     # 0x2311a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movl 0x4(%r14), %edx
movq 0x18(%r14), %rcx
leaq 0x10262(%rip), %rsi     # 0x2313d
jmp 0x12f1a
leaq 0x101ba(%rip), %rdi     # 0x2309e
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x101b6(%rip), %rsi     # 0x230b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x101c2(%rip), %rsi     # 0x230dc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x131ac
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2d, 0x1c(%rsi)
je 0x13144
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x13112
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x13112
cmpl $0x1, (%rbx)
jne 0x131ac
cmpl $0x2d, 0x1c(%rbx)
jne 0x131ac
movq 0x28(%rbx), %r15
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x4c16
movq %rax, 0x28(%rbx)
testq %r15, %r15
je 0x131b2
cmpq %r15, %rax
je 0x131bb
leaq 0x110d3(%rip), %rdi     # 0x2424b
callq 0x40d0
cmpq $0x0, 0x28(%rbx)
leaq 0x11051(%rip), %rax     # 0x241da
leaq 0x144ac(%rip), %rsi     # 0x2763c
cmoveq %rax, %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdx
leaq 0x1103f(%rip), %rdi     # 0x241e2
xorl %eax, %eax
callq 0x4140
jmp 0x131c7
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1105e(%rip), %rdi     # 0x24217
jmp 0x131c2
leaq 0x1106a(%rip), %rdi     # 0x2422c
callq 0x40d0
cmpq $0x0, 0x28(%rbx)
leaq 0x11007(%rip), %rax     # 0x241da
leaq 0x14462(%rip), %rsi     # 0x2763c
cmoveq %rax, %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdx
leaq 0x10fc8(%rip), %rdi     # 0x241b5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x1323f
leaq (,%r15,8), %r12
addq 0x8(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x1323a
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x1224b
addq $0x38, %r12
jmp 0x1321e
incq %r15
jmp 0x1320a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x23ec9(%rip), %rbx     # 0x37380
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
je 0x13596
movq %rax, %r14
movq %r15, %rdi
callq 0x4110
leaq (%rax,%r14), %rdi
pushq $0x29
popq %rsi
callq 0x4150
testq %rax, %rax
je 0x13596
movq %r14, %rcx
cmpq %rax, %rcx
ja 0x134fb
movb $0x20, (%rcx)
incq %rcx
jmp 0x134ee
movb $0x30, (%r14)
decq %r14
movb (%r14), %al
cmpb $0x20, %al
jne 0x13513
cmpq %rbx, %r14
ja 0x134ff
jmp 0x13596
cmpb $0x9, %al
jne 0x1351c
cmpq %rbx, %r14
ja 0x134ff
cmpq %rbx, %r14
setbe %cl
cmpb $0x3d, %al
setne %al
orb %cl, %al
jne 0x13596
callq 0x42e0
movq (%rax), %rax
movsbq -0x1(%r14), %rcx
testb $0x8, (%rax,%rcx,2)
je 0x13596
movq %rbx, %rdi
callq 0x4110
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x13568
movzbl (%rcx,%rbx), %edx
cmpl $0x29, %edx
je 0x13561
cmpl $0x28, %edx
jne 0x13563
incl %ebp
jmp 0x13563
decl %ebp
incq %rcx
jmp 0x1354a
movl $0x203a43, 0x23e0e(%rip) # imm = 0x203A43
testl %ebp, %ebp
jle 0x13588
decl %ebp
movq %rbx, %rdi
callq 0x4110
movw $0x28, (%rax,%rbx)
jmp 0x13572
movq %rbx, %rdi
callq 0x4110
movw $0x30, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1386f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x23199(%rip), %r15     # 0x369d8
testq %rbx, %rbx
je 0x1386f
cmpl $0x0, (%r15)
je 0x1386f
cmpl $0x4, (%rbx)
jne 0x1387b
movl 0x1c(%rbx), %eax
orl $0x4, %eax
cmpl $0xe, %eax
jne 0x1387b
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x13825
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x1383f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x23aee(%rip), %rdi     # 0x37370
movl 0x32570(%rip), %edx     # 0x45df8
leal 0x1(%rdx), %eax
movl %eax, 0x32567(%rip)     # 0x45df8
leaq 0x105e4(%rip), %rsi     # 0x23e7c
xorl %eax, %eax
callq 0x41c0
movq 0x23aca(%rip), %rsi     # 0x37370
movq %r14, %rdi
callq 0x1ece2
movq 0x23abb(%rip), %rcx     # 0x37370
leaq 0x179bd(%rip), %rdi     # 0x2b279
pushq $0x3
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x42c0
leaq 0x2a21e(%rip), %r15     # 0x3daf0
leaq 0x23aa7(%rip), %r12     # 0x37380
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b0
movb $0x0, 0x23a95(%rip)     # 0x37380
movq %rbx, %rdi
callq 0x8cbf
movq 0x23a76(%rip), %rsi     # 0x37370
movq %r12, %rdi
callq 0x4170
movq %r12, %rdi
movq %r15, %rsi
callq 0x40b0
movl $0x782d782d, 0x2a1d9(%rip) # imm = 0x782D782D
movw $0x2d, 0x2a1d4(%rip)    # 0x3daf4
movq 0x23a49(%rip), %rcx     # 0x37370
leaq 0x102ad(%rip), %rdi     # 0x23bdb
pushq $0x5
popq %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x2365f(%rip)     # 0x37380
leaq 0xee6e(%rip), %rdi      # 0x22b96
callq 0x106f2
movq %r14, %rdi
callq 0x106f2
movl 0x2bdb9(%rip), %eax     # 0x3faf4
movl %eax, 0x2f473(%rip)     # 0x431b4
movl 0x2bdb1(%rip), %eax     # 0x3faf8
movl %eax, 0x320bb(%rip)     # 0x45e08
movl 0x2bd9d(%rip), %eax     # 0x3faf0
movl %eax, 0x2f457(%rip)     # 0x431b0
leaq 0xfbda(%rip), %rsi      # 0x2393a
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0x13d74
movb $0x1, 0x29d6c(%rip)     # 0x3dae0
movq %rbx, %rdi
callq 0xfc6c
movb $0x0, 0x29d5d(%rip)     # 0x3dae0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x227f5(%rip), %rax     # 0x36a08
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4637
testq %rax, %rax
je 0x14240
movl $0x2, (%rax)
movl %ebx, 0x1c(%rax)
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
andq $0x0, 0x40(%rax)
popq %rbx
retq
movq 0x1fdb1(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
leaq 0x105c2(%rip), %rdi     # 0x24813
callq 0x4170
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x227a0(%rip), %rax     # 0x36a08
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4637
testq %rax, %rax
je 0x14294
movl $0x3, (%rax)
movl %ebx, 0x1c(%rax)
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
popq %rbx
retq
movq 0x1fd5d(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
leaq 0x10590(%rip), %rdi     # 0x24835
callq 0x4170
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x2274c(%rip), %rax     # 0x36a08
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4637
testq %rax, %rax
je 0x142df
movl $0x1, (%rax)
movl %ebx, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
retq
movq 0x1fd12(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
leaq 0x10568(%rip), %rdi     # 0x24858
callq 0x4170
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x22701(%rip), %rax     # 0x36a08
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4637
testq %rax, %rax
je 0x1432e
movl $0x4, (%rax)
movl %ebx, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
popq %rbx
retq
movq 0x1fcc3(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
leaq 0x1053d(%rip), %rdi     # 0x2487c
callq 0x4170
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
movq 0x1f83a(%rip), %r13     # 0x33ff8
leaq 0x1f9db(%rip), %r15     # 0x341a0
leaq 0x1029f(%rip), %rbx     # 0x24a6b
testq %rax, %rax
je 0x1483b
movl (%rax), %edi
cmpl $0x3, %edi
jne 0x147e0
cmpl $0x1, 0x1c(%rax)
jne 0x147cc
jmp 0x147f7
cmpl $0x1, %edi
je 0x1483b
cmpl $0x4, %edi
jne 0x14803
movl 0x1c(%rax), %ebp
cmpl $0x2, %ebp
je 0x147fd
cmpl $0x5, %ebp
jne 0x14806
movq 0x38(%rax), %rax
jmp 0x147cc
movq 0x30(%rax), %rax
jmp 0x147cc
movl 0x1c(%rax), %ebp
movq (%r13), %r14
movq (%r15), %rax
movq %rax, (%rsp)
callq 0x14527
movq %rax, %r12
movl %ebp, %edi
callq 0x1467f
movq %r14, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
movq %r12, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x41c0
xorl %eax, %eax
jmp 0x147cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/tree.c
// Function: find_params
void
find_params(treenode *decl, FindFunction find)
{
	if (!decl)
		return;

	switch(decl->hdr.which) {
	case NODE_T:
	        switch(decl->hdr.type) {
		case TN_DECL:
#if 0
			find_ident_name(decl,decl,NULL,find);
#else
			if (decl->rnode
			&&  decl->rnode->hdr.which == NODE_T
			&&  decl->rnode->hdr.type == TN_FUNC_DECL)
				find_params(decl->rnode, find);
			else
				find_ident_name(decl,decl,NULL,find);
#endif
			break;
	
		case TN_DECL_LIST:
		case TN_DECLS:
			find_params(decl->lnode,find);
			find_params(decl->rnode,find);
			break;

		case TN_IDENT_LIST:
		case TN_PARAM_LIST:
			find_ident_name(decl->lnode,decl->lnode,NULL,find);
			find_ident_name(decl->rnode,decl->rnode,NULL,find);
			break;
	
		case TN_FUNC_DECL:
			find_params(decl->rnode,find);
			break;
	
		default:
			fprintf(stderr, "%s: parse error:%d: "
				"unknown node type (%s) in find_params\n",
				progname, decl->hdr.line,
				name_of_node(decl->hdr.type));
			break;
		}
		break;

	case LEAF_T:
		if (0) {	leafnode *leaf = (leafnode *) decl;
			switch (leaf->hdr.type) {
			case TN_IDENT:
				printf("	%s\n", leaf->data.sval->str);
				break;
			default:
				printf("	<leaftype: %d>\n", leaf->hdr.type);
				break;
			}
		}
		find_ident_name(decl,decl,NULL,find);
		break;

	case IF_T:
	case FOR_T:
	case NONE_T:
	default:
		fprintf(stderr, "%s: parse error:%d: unknown node in find_params,"
			"  type: %s\n", progname, decl->hdr.line,
			name_of_nodetype(decl->hdr.which));
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xfe75(%rip), %r15      # 0x246d0
testq %rdi, %rdi
je 0x148b8
movq %rdi, %r14
movl (%rdi), %edi
cmpl $0x4, %edi
jne 0x148ab
movl 0x1c(%r14), %edi
leal -0x2(%rdi), %eax
cmpl $0xe, %eax
ja 0x1492f
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x1484a
movq 0x38(%r14), %rdi
jmp 0x1485b
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x148b0
cmpl $0x4, (%rdi)
jne 0x148b0
cmpl $0x2, 0x1c(%rdi)
je 0x1485b
jmp 0x148b0
cmpl $0x1, %edi
jne 0x148ef
movq %r14, %rdi
movq %r14, %rsi
jmp 0x148db
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r14), %rdi
movq %rdi, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x1469d
movq 0x38(%r14), %rdi
movq %rdi, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1469d
movq 0x1f702(%rip), %rax     # 0x33ff8
movq (%rax), %rbx
leaq 0x1f8a0(%rip), %rax     # 0x341a0
movq (%rax), %r15
movl 0x10(%r14), %ebp
callq 0x14527
leaq 0x101cf(%rip), %rsi     # 0x24ae2
movq %rbx, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x41c0
movq 0x1f6c2(%rip), %rax     # 0x33ff8
movq (%rax), %rbx
leaq 0x1f860(%rip), %rax     # 0x341a0
movq (%rax), %r15
movl 0x10(%r14), %ebp
callq 0x1467f
leaq 0x10154(%rip), %rsi     # 0x24aa7
jmp 0x14913
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/tree.c
// Function: find_components
void
find_components(treenode *decl, treenode *def,
                      treenode *container, FindFunction find)
{
    if (!decl)
        return;

    switch(decl->hdr.which)
    {
        case NODE_T:
        {
            switch(decl->hdr.type)
            {
            case TN_COMP_DECL:
            case TN_DECL:
                find_ident_name(decl,decl,container,find);
                break;

            case TN_DECL_LIST:
            case TN_DECLS:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FIELD_LIST:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FUNC_DECL:
                find_components(decl->rnode,def,container,find);
                break;

            default:
                fprintf(stderr,
                    "%s: parse error: "
                    "unknown node type (%s) in find_components\n",
                    progname, name_of_node(decl->hdr.type));
                break;
            }
        }
    break;

    case LEAF_T:
    case IF_T:
    case FOR_T:
    case NONE_T:
    default:
        fprintf(stderr,
         "%s: parse error: unknown node %s in find_components;\n"
         "  type is: %s\n", progname, print_ptr(decl), name_of_nodetype(decl->hdr.which));
        break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xfd9b(%rip), %r13      # 0x2470c
testq %rbx, %rbx
je 0x149af
cmpl $0x4, (%rbx)
jne 0x149d8
movl 0x1c(%rbx), %edi
leal -0x8(%rdi), %eax
cmpl $0x9, %eax
ja 0x149a4
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x30(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x14955
jmp 0x149a9
cmpl $0x2, %edi
jne 0x149b9
movq 0x38(%rbx), %rbx
jmp 0x14971
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpl $0x5, %edi
jne 0x14a22
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1469d
movq 0x1f619(%rip), %rax     # 0x33ff8
movq (%rax), %r14
leaq 0x1f7b7(%rip), %rax     # 0x341a0
movq (%rax), %r15
movq %rbx, %rdi
callq 0x141e8
movl (%rbx), %edi
callq 0x14527
leaq 0x10158(%rip), %rsi     # 0x24b5a
leaq 0x31417(%rip), %rcx     # 0x45e20
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x41c0
movq 0x1f5cf(%rip), %rax     # 0x33ff8
movq (%rax), %rbx
leaq 0x1f76d(%rip), %rax     # 0x341a0
movq (%rax), %r14
callq 0x1467f
leaq 0x100dc(%rip), %rsi     # 0x24b1e
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x41c0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x313d2(%rip), %rbx     # 0x45e40
testq %rbx, %rbx
je 0x14a92
movq 0x38(%rbx), %rax
movq %rax, 0x313c2(%rip)     # 0x45e40
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x14a9d
pushq $0x40
popq %rdi
callq 0x4739
movq %rax, %rbx
movq %r15, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x19e82
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x14b00
pushq $0x50
popq %rdi
xorl %esi, %esi
callq 0x43ec
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x14b0b
movq %r14, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
andq $0x0, (%rbx)
andq $0x0, 0x38(%rbx)
jmp 0x14b27
movq 0x10(%rbx), %rdi
callq 0x4738
jmp 0x14b1d
movq 0x10(%rbx), %rdi
callq 0x4738
movq 0x30(%rbx), %rdi
callq 0x1a328
movq %rbx, %rdi
callq 0x4738
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x14ba7
movq (%rdi), %rax
movq %rax, 0x38(%rsi)
testq %rax, %rax
jne 0x14ba4
movq %rsi, 0x8(%rdi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x14c30
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x21df7(%rip), %rcx     # 0x36a08
movq %rax, (%rcx)
testq %rax, %rax
je 0x14c49
movq 0x30(%rax), %rdi
callq 0x1a2bb
movq (%rbx), %rax
testq %rax, %rax
je 0x14c3d
movq 0x18(%rax), %rax
jmp 0x14c3f
leaq 0x21dd1(%rip), %rax     # 0x36a08
andq $0x0, (%rax)
jmp 0x14c49
xorl %eax, %eax
leaq 0x3120a(%rip), %rcx     # 0x45e50
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/treestk.c
// Function: tree_parse
int
tree_parse(TreeStack *treestk, int parse_all)
{
    int cnt = 0;

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

    do {
#if 0
        while(yyparse())
            ;
#else
	yyparse();	/* returns 1 on error 0 on accept */
#endif
        cnt++;
        get_next_file(treestk);

        if (is_empty(treestk))
            break;

    } while (parse_all);

    return(cnt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x14c7c
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x14c7c
movl %esi, %ebp
xorl %ebx, %ebx
callq 0x1a7a4
incl %ebx
movq %r14, %rdi
callq 0x14c83
testl %ebp, %ebp
je 0x14c7c
cmpq $0x0, (%r14)
jne 0x14c63
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/treestk.c
// Function: get_next_file
int
get_next_file(TreeStack *treestk)
{
    if (is_empty(treestk)){
        Parse_TOS = (Stk_Item *) NULL;
        return(0);
    }

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

    reset_position(treestk);

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

    return(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14cc6
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x14cc6
leaq 0x21d74(%rip), %rax     # 0x36a10
movq (%rax), %r14
testq %r14, %r14
je 0x14cd5
movq %rbx, %rdi
callq 0x14ba8
testq %rax, %rax
je 0x14cfb
movq (%r14), %rcx
movq %rcx, 0x38(%rax)
testq %rcx, %rcx
jne 0x14cc1
movq %rax, 0x8(%r14)
movq %rax, (%r14)
jmp 0x14cfb
leaq 0x21d3b(%rip), %rax     # 0x36a08
andq $0x0, (%rax)
xorl %eax, %eax
jmp 0x14d0c
movq 0x1f2f4(%rip), %rax     # 0x33fd0
movq (%rax), %rsi
leaq 0x1010d(%rip), %rdi     # 0x24df3
callq 0x4170
movq %rbx, %rdi
callq 0x14ba8
movq %rax, %rdi
callq 0x14b30
movq %rbx, %rdi
callq 0x14bfe
xorl %eax, %eax
cmpq $0x0, (%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/treestk.c
// Function: handle_new_file
void
handle_new_file(TreeStack *treestk, FILE *fp, char *fname)
{
    Stk_Item *stk_item;

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x14a5c
testq %rax, %rax
je 0x14d49
testq %rbx, %rbx
je 0x14d40
movq (%rbx), %rcx
movq %rcx, 0x38(%rax)
testq %rcx, %rcx
jne 0x14d3d
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x14bfe
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: doit
char *
doit(leafnode *leaf, int how)
{	scopetab_t *z;
	static char bstr[1024];
	static char lstr[1024];

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c39b
movl %esi, %ebx
movq %rdi, %r14
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1c348
movq 0x18(%rax), %r12
testq %r12, %r12
jne 0x1c34b
xorl %r12d, %r12d
movb $0x0, 0x2df9e(%rip)     # 0x4a2f0
testl %ebx, %ebx
je 0x1c38f
cmpl $0x1, %ebx
je 0x1c3e0
cmpl $0x2, %ebx
jne 0x1c39f
movl 0x10(%r14), %edx
leaq 0x2db81(%rip), %r15     # 0x49ef0
leaq 0x7d17(%rip), %rsi      # 0x2408d
movq %r15, %rdi
xorl %eax, %eax
callq 0x42a0
leaq 0x2df69(%rip), %rdi     # 0x4a2f0
movq %r15, %rsi
callq 0x4290
testq %r12, %r12
je 0x1c3b2
movq 0x18(%r12), %rdx
jmp 0x1c3b9
xorl %eax, %eax
jmp 0x1c3a6
leaq 0x2df4a(%rip), %rax     # 0x4a2f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x56e2(%rip), %rdx      # 0x21a9b
leaq 0x2db30(%rip), %r15     # 0x49ef0
leaq 0xf009(%rip), %rsi      # 0x2b3d0
movq %r15, %rdi
xorl %eax, %eax
callq 0x42a0
leaq 0x2df18(%rip), %rdi     # 0x4a2f0
movq %r15, %rsi
callq 0x4290
movq 0x30(%r14), %rdi
callq 0x463c
testl %ebx, %ebx
leaq 0x6866(%rip), %rdx      # 0x22c58
leaq 0x7b98(%rip), %rcx      # 0x23f91
cmoveq %rdx, %rcx
leaq 0x2daec(%rip), %rbx     # 0x49ef0
leaq 0xefca(%rip), %rsi      # 0x2b3d5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x42a0
leaq 0x2ded1(%rip), %rdi     # 0x4a2f0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4290
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: dep_node
DuG *
dep_node(SymList *a, int imark)
{	DuG *g;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x2e2ae(%rip), %rbx     # 0x4a6f0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1c459
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
je 0x1c4b1
addq $0x18, %rbx
jmp 0x1c442
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %rbx
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0x1c489
leaq 0x17d2c(%rip), %rax     # 0x341a0
movq (%rax), %rsi
leaq 0xef5c(%rip), %rdi      # 0x2b3da
xorl %eax, %eax
callq 0x4140
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
movl 0x2e263(%rip), %eax     # 0x4a6f8
orl %eax, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
movq 0x2e24c(%rip), %rax     # 0x4a6f0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2e241(%rip)     # 0x4a6f0
jmp 0x1c4b4
orl %ebp, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: dep_edge
int
dep_edge(DuG *a, DuG *b, int dist)
{	DuGP *e;

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

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

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

	return 1;
}

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
cmpq (%rsi), %rcx
je 0x1c50b
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rbx
movq %rbx, %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x1c4ec
leaq 0x10(%rdx), %rcx
cmpq %r14, (%rdx)
jne 0x1c4d9
jmp 0x1c507
pushq $0x18
popq %rdi
callq 0x4739
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: dep_trans
void
dep_trans(void)	/* transitive closure */
{	DuG *g, *t;
	DuGP *s, *u;
	int dist, cnt;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
leaq 0x2e1d3(%rip), %r14     # 0x4a6f0
movq %r14, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1c560
movq %rbx, %r15
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x1c55a
movq (%r15), %r12
movq 0x10(%r12), %r12
testq %r12, %r12
je 0x1c52b
movl 0x8(%r12), %edx
addl 0x8(%r15), %edx
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x1c4bc
addl %eax, %ebp
jmp 0x1c537
addq $0x18, %rbx
jmp 0x1c520
movq %r14, %rbx
testl %ebp, %ebp
movl $0x0, %ebp
jg 0x1c520
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq