LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: x_stmnt
char *
x_stmnt(treenode *n)	/* service routine for lts.c */
{	char *p;

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

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

	return OutBuf;
}

// Assembly:
testq %rdi, %rdi
je 0xac36
movl 0x1c(%rdi), %eax
cmpl $0x23, %eax
je 0xac3e
cmpl $0x4, %eax
jne 0xac46
leaq 0x193c7(%rip), %rax     # 0x23ffc
retq
leaq 0x18e5d(%rip), %rax     # 0x23a9a
retq
leaq 0x193af(%rip), %rax     # 0x23ff4
retq
pushq %rbp
pushq %r14
pushq %rbx
movq $0x0, 0x2e71b(%rip) # 0x39370
xorl %ebp, %ebp
movl %ebp, 0x2e71b(%rip)     # 0x39378
leaq 0x2dd74(%rip), %r14     # 0x389d8
movl $0x1, (%r14)
movb $0x0, 0x2e70e(%rip)     # 0x39380
leaq 0x2e707(%rip), %rbx     # 0x39380
callq 0xaca3
movl %ebp, (%r14)
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0xac8f
testl %eax, %eax
jne 0xac92
jmp 0xac97
movb $0x27, (%rbx)
incq %rbx
jmp 0xac81
leaq 0x2e6e2(%rip), %rax     # 0x39380
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: nx_stmnt
char *
nx_stmnt(treenode *n)
{
	if (!n
	||  n->hdr.type == TN_STEMNT
	||  n->hdr.type == TN_BLOCK)
	{	return "";
	}

	do_level = 0;

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

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

	return rm_decor(OutBuf);
}

// Assembly:
testq %rdi, %rdi
je 0xc0bc
movl 0x1c(%rdi), %eax
cmpl $0x4, %eax
je 0xc0bc
cmpl $0x23, %eax
jne 0xc0c4
leaq 0x19fce(%rip), %rax     # 0x26091
retq
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
movl %ebp, 0x2d2a8(%rip)     # 0x39378
leaq 0x2c901(%rip), %r14     # 0x389d8
movl $0x1, (%r14)
movb %bpl, 0x2d29b(%rip)     # 0x39380
leaq 0x2d294(%rip), %rbx     # 0x39380
callq 0xaca3
movl %ebp, (%r14)
movb %bpl, 0x2a297(%rip)     # 0x36392
movw $0x2d2d, 0x2a28c(%rip)  # imm = 0x2D2D
movb %bpl, 0x2e275(%rip)     # 0x3a380
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc117
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: rm_decor
char *
rm_decor(char *R)	/* strip "P...->"  and "now." decorations */
{	char *z, *y, *r;
	char patt[2048];
	Decor *d;

	sprintf(patt, "Pp_%s->", fct_name);

	r = R;
	fdecors = decors;
	decors = (Decor *) 0;

	while ((z = strstr(r, patt)) != NULL)
	{	new_decor(z, strlen(patt));
		r = z+strlen(patt);
	}
	r = R;
	while ((z = strstr(r, "now.")) != NULL)
	{	new_decor(z, strlen("now."));
		r = z+strlen("now.");
	}
	if (!decors) return R;

	z = &IntBuf[0];
	y = R;

	if (0)
	{	for (d = decors; d; d = d->nxt)
			fprintf(stderr, "\t%d .. %d, %s\n",
				(int)(d->from - y), d->ln, d->from);
		fprintf(stderr, "\n");
	}
	for (d = decors; d; d = d->nxt)
	{	r = d->from;
		strncpy(z, y, (r-y));
		z += (r-y);
		y = r + d->ln; /* skip over decoration */
	}
	strcpy(z, y);

	if (0)
	{	fprintf(stderr, "in : %s\n", R);
		fprintf(stderr, "out: %s\n\n", IntBuf);
	}
	return &IntBuf[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %rbx
leaq 0x17ef8(%rip), %rsi     # 0x24029
leaq 0x2a258(%rip), %rdx     # 0x36390
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x42a0
movq 0x2f234(%rip), %rax     # 0x3b380
movq %rax, 0x2f235(%rip)     # 0x3b388
movq $0x0, 0x2f222(%rip) # 0x3b380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xc1a0
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x4110
movq %rax, %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0xc3ff
addq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x42d0
movq %rax, %r14
testq %rax, %rax
jne 0xc17f
leaq 0x17e8a(%rip), %rsi     # 0x24031
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0xc1e2
movq %rax, %r14
leaq 0x17e73(%rip), %r15     # 0x24031
movq %r14, %rdi
movl $0x4, %esi
callq 0xc3ff
addq $0x4, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x42d0
movq %rax, %r14
testq %rax, %rax
jne 0xc1be
movq 0x2f197(%rip), %r12     # 0x3b380
testq %r12, %r12
je 0xc238
leaq 0x2e18b(%rip), %r14     # 0x3a380
movq %r14, %r15
movq (%r12), %r13
movq %r13, %r14
subq %rbx, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4090
addq %r15, %r14
movswq 0x8(%r12), %rbx
addq %r13, %rbx
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xc1f5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x2e148(%rip), %rbx     # 0x3a380
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: handle_double
void
handle_double(FILE *lf, char *s)
{	char *t, *v;

	v = s;
	while ((t = strstr(v, NeCode)) != NULL)
	{	*t = '\0';
		handle_lf(lf, v);
		fprintf(lf, "%%%%");
		*t = '_';
		v = t+strlen(NeCode);
	}
	handle_lf(lf, v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17d94(%rip), %rsi     # 0x24004
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
je 0xc2ca
movq %rax, %r12
leaq 0x17d8d(%rip), %r15     # 0x24014
leaq 0x17d76(%rip), %r13     # 0x24004
movb $0x0, (%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41d0
movb $0x5f, (%r12)
movq %r12, %r14
addq $0xf, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x42d0
movq %rax, %r12
testq %rax, %rax
jne 0xc28e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: handle_special
void
handle_special(FILE *lf, char *s, char *last)
{	char *t, *v;

	if ((t = strstr(s, "%")) != NULL)
	{	if (*(t+1) != '%')
			return;	/* rogue % slipped through */
	}

	v = s;
	while ((t = strstr(v, EnCode)) != NULL)
	{	*t = '\0';
		handle_double(lf, v);
		fprintf(lf, "%%");
		*t = '_';
		v = t+strlen(EnCode);
	}
	handle_double(lf, v);

	fprintf(lf, "%s", last);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movl $0x25, %esi
callq 0x4130
testq %rax, %rax
je 0xc30e
cmpb $0x25, 0x1(%rax)
jne 0xc393
leaq 0x17d04(%rip), %rsi     # 0x24019
movq %r15, %rdi
callq 0x42d0
testq %rax, %rax
je 0xc36f
movq %rax, %r13
leaq 0x17cea(%rip), %r12     # 0x24016
leaq 0x17ce6(%rip), %rbp     # 0x24019
movb $0x0, (%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0xc25a
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x41d0
movb $0x5f, (%r13)
movq %r13, %r15
addq $0xf, %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x42d0
movq %rax, %r13
testq %rax, %rax
jne 0xc333
movq %r14, %rdi
movq %r15, %rsi
callq 0xc25a
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_decor
void
add_decor(Decor *d)
{	Decor *f, *lf = (Decor *) 0;

	for (f = decors; f; lf = f, f = f->nxt)
		if (d->from < f->from)
		{	/* insert d before f */
			if (lf)
			{	d->nxt = f;
				lf->nxt = d;
			} else
			{	d->nxt = decors;
				decors = d;
			}
			return;
		}
	if (lf)
		lf->nxt = d;
	else
		decors = d;
}

// Assembly:
movq 0x2efd7(%rip), %rcx     # 0x3b380
leaq 0x2efd0(%rip), %rax     # 0x3b380
testq %rcx, %rcx
je 0xc3fb
movq (%rdi), %rsi
cmpq (%rcx), %rsi
jae 0xc3c5
xorl %r8d, %r8d
movq %rcx, %rdx
jmp 0xc3dc
movq %rcx, %r9
movq 0x10(%r9), %rdx
testq %rdx, %rdx
je 0xc3f4
movq %r9, %r8
movq %rdx, %r9
cmpq (%rdx), %rsi
jae 0xc3c8
testq %r8, %r8
je 0xc3ee
movq %rdx, 0x10(%rdi)
addq $0x10, %r8
movq %r8, %rax
jmp 0xc3fb
movq %rcx, 0x10(%rdi)
jmp 0xc3fb
addq $0x10, %r9
movq %r9, %rax
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: new_decor
void
new_decor(char *p, int n)
{	Decor *f;

	if (fdecors)
	{	f = fdecors;
		fdecors = f->nxt;
	} else
		f = (Decor *) e_malloc(sizeof(Decor));
	f->from = p;
	f->ln = (short) n;
	f->nxt = (Decor *) 0;
	add_decor(f);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2ef7a(%rip), %rax     # 0x3b388
testq %rax, %rax
je 0xc420
movq 0x10(%rax), %rcx
movq %rcx, 0x2ef6a(%rip)     # 0x3b388
jmp 0xc42a
movl $0x18, %edi
callq 0x6321
movq %rbx, (%rax)
movw %bp, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq 0x2ef40(%rip), %rdx     # 0x3b380
leaq 0x2ef39(%rip), %rcx     # 0x3b380
testq %rdx, %rdx
je 0xc470
cmpq %rbx, (%rdx)
jbe 0xc457
movq %rdx, 0x10(%rax)
jmp 0xc470
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0xc46c
cmpq %rbx, (%rdx)
jbe 0xc457
movq %rdx, 0x10(%rax)
addq $0x10, %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_fct
void
add_fct(char *s, char *t)	/* names of fcts used in expressions */
{	Fcts *f;

	f = (Fcts *) e_malloc(sizeof(Fcts));
	f->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->level = Down;

	f->tg = (char *) e_malloc(strlen(t)+1);
	strcpy(f->tg, t);
	f->nxt = fcts;
	fcts = f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x40, %edi
callq 0x6321
movq %rax, %r14
movq %r15, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movl 0x2eeda(%rip), %eax     # 0x3b390
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2eeb8(%rip), %rax     # 0x3b398
movq %rax, 0x38(%r14)
movq %r14, 0x2eead(%rip)     # 0x3b398
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_include
void
add_include(char *s)
{	Fcts *f;

	f = (Fcts *) e_malloc(sizeof(Fcts));
	f->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->level = Down;

	f->nxt = incls;
	incls = f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40, %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl 0x2ee67(%rip), %eax     # 0x3b390
movl %eax, 0x2c(%r14)
movq 0x2ee6c(%rip), %rax     # 0x3b3a0
movq %rax, 0x38(%r14)
movq %r14, 0x2ee61(%rip)     # 0x3b3a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: dump_fct
void
dump_fct(FILE *fd)
{	Fcts *f;

	for (f = fcts; f; f = f->nxt)
	{	if (f->level == 0)
		{	if (f->nm[0] != '(')
			fprintf(fd, "Function	%s\n", f->nm);
	}	}

	for (f = incls; f; f = f->nxt)
	{	if (f->level == 0)
			fprintf(fd, "Include	%s\n", f->nm);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2ee42(%rip), %r15     # 0x3b398
testq %r15, %r15
je 0xc587
leaq 0x17ad4(%rip), %r14     # 0x24036
cmpl $0x0, 0x2c(%r15)
jne 0xc57e
movq (%r15), %rdx
cmpb $0x28, (%rdx)
je 0xc57e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xc562
movq 0x2ee12(%rip), %r15     # 0x3b3a0
testq %r15, %r15
je 0xc5ba
leaq 0x17aa9(%rip), %r14     # 0x24043
cmpl $0x0, 0x2c(%r15)
jne 0xc5b1
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xc59a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_substitute
void
add_substitute(char *s, char *t)	/* substitute rules defined in lut */
{	Fcts *f;

	if (strstr(t, s))
	{	fprintf(stderr, "%s: error: lhs of Substitute Rule may not appear on rhs\n",
			progname);
		return;
	}
if (0) fprintf(stderr, "map %s -> %s\n", s, t);

	f = modex_fct_el(s);
	f->level = Down;

	if (t)
	{	f->tg = (char *) e_malloc(strlen(t)+1);
		strcpy(f->tg, t);
	} else
		f->tg = (char *) 0;
	f->nxt = maps;
	maps = f;

	if (0) printf("Sub <%s> <%s>\n", s, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc637
movq %r14, %rdi
callq 0xc63e
movq %rax, %r14
movl 0x2eda5(%rip), %eax     # 0x3b390
movl %eax, 0x2c(%r14)
testq %rbx, %rbx
je 0xc615
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
jmp 0xc61d
movq $0x0, 0x8(%r14)
movq 0x2ed84(%rip), %rax     # 0x3b3a8
movq %rax, 0x38(%r14)
movq %r14, 0x2ed79(%rip)     # 0x3b3a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4668
jmp 0xc62f
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: modex_fct_el
static Fcts *
modex_fct_el(char *s)
{	Fcts *f;

	f = (Fcts *) e_malloc(sizeof(Fcts));
	memset(f, 0, sizeof(Fcts));
	f->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(f->nm, s);

	if (allprocs
	||  strcmp(fct_name, want) == 0)
		f->wanted = 1;

	if (in_call > 0) f->fc = 1;
	else if (in_args > 0) f->fc = 2;
	else if (is_label > 0) f->fc = 3;
	else f->fc = 0;

	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq 0x6321
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x2c3df(%rip), %rax     # 0x38a68
cmpl $0x0, (%rax)
je 0xc697
movl $0x1, 0x28(%rbx)
jmp 0xc6b1
leaq 0x29b0a(%rip), %rax     # 0x361a8
movq (%rax), %rsi
leaq 0x29ce8(%rip), %rdi     # 0x36390
callq 0x41c0
testl %eax, %eax
je 0xc68e
cmpl $0x0, 0x2ed00(%rip)     # 0x3b3b8
jle 0xc6c3
movl $0x1, 0x30(%rbx)
jmp 0xc6ee
cmpl $0x0, 0x2ecf2(%rip)     # 0x3b3bc
jle 0xc6d5
movl $0x2, 0x30(%rbx)
jmp 0xc6ee
cmpl $0x0, 0x2ece4(%rip)     # 0x3b3c0
jle 0xc6e7
movl $0x3, 0x30(%rbx)
jmp 0xc6ee
movl $0x0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_hidden
void
add_hidden(char *s, char *t, int d, int ln)
{	Fcts *g;

	if (strlen(s) == 0)
		return;

	for (g = modex_hidden; g; g = g->nxt)
		if (strcmp(g->dt, s) == 0
		&&  (strcmp(g->nm, t) == 0
		||   (g->full && strcmp(g->full, t) == 0)))
			return;

if (debug)
	fprintf(stderr, "%3d: add_hidden typ=%s nam=%s deriv=%d (incall=%d,inargs=%d,islabel=%d)\n",
		ln, s, t, d, in_call, in_args, is_label);

	g = modex_fct_el(s);
	g->dt = g->nm;
	g->derived = d;
	g->lno = ln;

	t = sep_decor(t, g);

	g->nm = (char *) e_malloc(strlen(t)+1);
	strcpy(g->nm, t);
if (debug)
	fprintf(stderr, "---name %s -- \n", t);

	g->tg = (char *) e_malloc(strlen(fct_name)+1);
	strcpy(g->tg, fct_name);	/* to record where we saw the reference */

	g->nxt = modex_hidden;
	modex_hidden = g;
}

// Assembly:
cmpb $0x0, (%rdi)
je 0xc7ed
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x2ec94(%rip), %r12     # 0x3b3b0
testq %r12, %r12
je 0xc767
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x41c0
testl %eax, %eax
jne 0xc760
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0xc7e5
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0xc760
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0xc7e5
movq 0x38(%r12), %r12
jmp 0xc71c
movq %r15, %rdi
callq 0xc63e
movq %rax, %r15
movq (%rax), %rax
movq %rax, 0x10(%r15)
movl %r14d, 0x24(%r15)
movl %ebp, 0x34(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc7ee
movq %rax, %rbx
movq %rax, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x29bdc(%rip), %rbx     # 0x36390
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2ebd6(%rip), %rax     # 0x3b3b0
movq %rax, 0x38(%r15)
movq %r15, 0x2ebcb(%rip)     # 0x3b3b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: sep_decor
static char *
sep_decor(char *t, Fcts *g)
{	static char prep[512];

	if (strchr(t, '*')
	||  strchr(t, '['))	/* has decorations */
	{
		g->full = (char *) e_malloc(strlen(t)+1);
		strcpy(g->full, t);

		strcpy(prep, t);
		while ((t = strchr(prep, '*')) != NULL)
			*t = ' ';
		if ((t = strchr(prep, '[')) != NULL)
			*t = '\0';

		t = prep;
		while (isspace((int) *t))
			t++;
	}
	return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xc81d
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xc8b3
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x39bad(%rip), %r14     # 0x463f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
je 0xc87c
leaq 0x39b89(%rip), %rbx     # 0x463f0
movb $0x20, (%rax)
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xc867
leaq 0x39b6d(%rip), %rdi     # 0x463f0
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xc895
movb $0x0, (%rax)
callq 0x42e0
movq (%rax), %rax
leaq 0x39b4b(%rip), %rbx     # 0x463ef
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xc8a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_full_global
void
add_full_global(char *s, char *t, int derived, int ln)
{	Fcts *g;
	char *z;
	int cntr = 0;

	if (strlen(s) == 0
	||  strlen(t) == 0)
		return;

if (0)	printf("addfullglobal <%s> <%s> derived %d, ln %d\n", s, t, derived, ln);

tryagain:
	for (g = modex_globals; g; g = g->nxt)
		if (	/* strcmp(g->dt, s) == 0 &&	*/
		   (z = strstr(t, g->nm)))
		{
			if ((z == t
			&&  (*(z+strlen(g->nm)) == '['
			||   *(z+strlen(g->nm)) == ']'
			||   *(z+strlen(g->nm)) == '\0'
			||   *(z+strlen(g->nm)) == ' '))
			||  (*(z-2) == '*' && *(z-1) == ' '))
			{
				if (g->full
				&&  strcmp(g->full, t) == 0)
					return;

				if (Verbose&2)
					printf("add_full_global %s %s (%s)\n",
					s, t, g->full);

				g->full = (char *) e_malloc(strlen(t)+1);
				strcpy(g->full, t);

				if  (g->full[strlen(g->nm)] == ']')
				{	g->full[strlen(g->nm)] = '\0';
				}
				return;
			}
		}

if (0)	printf("%s: add_full_global not-found: <%s> <%s> <%d>\n", progname, s, t, cntr);

	if (cntr++ == 0)
	{	add_global(s, t, derived, ln);
		goto tryagain;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
cmpb $0x0, (%rdi)
je 0xcb92
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0xcb92
movq %rdi, %r14
movb $0x1, %r15b
movq 0x2e92b(%rip), %rbp     # 0x3b3c8
testq %rbp, %rbp
je 0xcafd
movq (%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x42d0
testq %rax, %rax
je 0xcaf7
movq %rax, %r12
cmpq %rbx, %rax
jne 0xcae7
movq %r13, %rdi
callq 0x4110
movzbl (%r12,%rax), %eax
leal -0x20(%rax), %ecx
cmpl $0x3d, %ecx
ja 0xcae3
movabsq $0x2800000000000001, %rdx # imm = 0x2800000000000001
btq %rcx, %rdx
jb 0xcb21
testl %eax, %eax
je 0xcb21
cmpb $0x2a, -0x2(%r12)
jne 0xcaf7
cmpb $0x20, -0x1(%r12)
je 0xcb21
movq 0x38(%rbp), %rbp
jmp 0xca9d
testb $0x1, %r15b
je 0xcb92
movq %r14, %rdi
movq %rbx, %rsi
movl (%rsp), %edx
movl 0x4(%rsp), %ecx
callq 0xc8be
xorl %r15d, %r15d
jmp 0xca96
movq 0x18(%rbp), %r15
testq %r15, %r15
je 0xcb39
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0xcb92
leaq 0x2bf3c(%rip), %rax     # 0x38a7c
testb $0x2, (%rax)
je 0xcb5c
leaq 0x17562(%rip), %rdi     # 0x240ae
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x4140
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x18(%rbp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq (%rbp), %rdi
movq 0x18(%rbp), %rbx
callq 0x4110
cmpb $0x5d, (%rbx,%rax)
jne 0xcb92
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: dump_decls
void
dump_decls(FILE *fd)
{	Fcts *g;

	for (g = modex_globals; g; g = g->nxt)
		if (!strstr(g->dt, "typedef")
		&&  !strstr(g->dt, "extern"))
		fprintf(fd, "Global	%s	%s\n",
			g->dt, g->nm);

	for (g = modex_hidden; g; g = g->nxt)
		if (!strstr(g->dt, "typedef")
		&&  !strstr(g->dt, "extern"))
		fprintf(fd, "%s	%s	%s\n",
			NONSTATE, g->dt, g->nm);

	for (g = modex_locals; g; g = g->nxt)
		if (!strstr(g->dt, "typedef")
		&&  !strstr(g->dt, "extern"))
		fprintf(fd, "Local	%s	%s	%s\n",
			g->dt, g->nm, g->tg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2d598(%rip), %rbp     # 0x3b3c8
testq %rbp, %rbp
je 0xde8b
leaq 0x16338(%rip), %r14     # 0x24174
leaq 0x16251(%rip), %r15     # 0x24094
leaq 0x16332(%rip), %r12     # 0x2417c
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xde82
movq %r13, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xde82
movq (%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41d0
movq 0x38(%rbp), %rbp
testq %rbp, %rbp
jne 0xde4a
movq 0x2d51e(%rip), %r12     # 0x3b3b0
testq %r12, %r12
je 0xdef6
leaq 0x162d6(%rip), %r14     # 0x24174
leaq 0x161ef(%rip), %r15     # 0x24094
leaq 0x162de(%rip), %r13     # 0x2418a
movq 0x10(%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xdeec
movq %rbp, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xdeec
movq (%r12), %r8
movq %rbx, %rdi
leaq 0x162ba(%rip), %rsi     # 0x24199
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x41d0
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xdeac
movq 0x2d4d3(%rip), %rbp     # 0x3b3d0
testq %rbp, %rbp
je 0xdf5c
leaq 0x1626b(%rip), %r14     # 0x24174
leaq 0x16184(%rip), %r15     # 0x24094
leaq 0x1627c(%rip), %r12     # 0x24193
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xdf53
movq %r13, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xdf53
movq (%rbp), %rcx
movq 0x8(%rbp), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41d0
movq 0x38(%rbp), %rbp
testq %rbp, %rbp
jne 0xdf17
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: spintype
char *
spintype(char *s, char *t)
{	static struct {
		char *tp; char *mp;
	} StS[] = {
		{ "bit ",	"bit" },	/* trailing space */
		{ "bool ",	"bool" },
		{ "byte ", 	"byte" },
		{ "pid ", 	"pid" },
		{ "int ",	"int" },
		{ "short ",	"short" },
		{ "uchar ", 	"byte" },
		{ "chan ", 	"chan" },

		{ "bit",	"bit" },	/* no trailing space */
		{ "bool",	"bool" },
		{ "byte", 	"byte" },
		{ "pid", 	"pid" },
		{ "int",	"int" },
		{ "short",	"short" },
		{ "uchar", 	"byte" },
		{ "chan", 	"chan" },
		{ (char *) 0,	 (char *) 0 }
	};
	int i;

	for (i = 0; StS[i].tp; i++)
		if (strcmp(s, StS[i].tp) == 0)
		{	if (!t
			||  strcmp(StS[i].mp, "chan") == 0
			||  (!strchr(t, '*')
			&&   !strstr(t, "sizeof")
			&&   !strstr(t, "->")
			&&   !strchr(t, '.')
			&&   !strchr(t, '{')
			&&  (!strchr(t, '[')
			||   (strchr(t, '[') == strrchr(t, '[')
			&&   !strchr(t, '=')))))
			{	return StS[i].mp;
			}
			break;
		}

	return (char *) 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x16222(%rip), %rsi     # 0x241a3
callq 0x41c0
testl %eax, %eax
je 0xdfbf
xorl %ebx, %ebx
leaq 0x273cd(%rip), %r12     # 0x35360
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq $0x100, %r13            # imm = 0x100
je 0xe043
movq 0x10(%rcx,%r12), %rsi
movq %r15, %rdi
callq 0x41c0
movq %r13, %rcx
testl %eax, %eax
jne 0xdf95
addq %r13, %r12
jmp 0xdfc6
leaq 0x2739a(%rip), %r12     # 0x35360
movq 0x8(%r12), %rbx
testq %r14, %r14
je 0xe043
leaq 0x16213(%rip), %rsi     # 0x241ea
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0xe043
movq %r14, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xe041
leaq 0x161f9(%rip), %rsi     # 0x241f5
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0xe041
leaq 0x16d11(%rip), %rsi     # 0x24d21
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0xe041
movq %r14, %rdi
movl $0x2e, %esi
callq 0x4130
testq %rax, %rax
jne 0xe041
movq %r14, %rdi
movl $0x7b, %esi
callq 0x4130
testq %rax, %rax
je 0xe050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xe043
movq %rax, %r15
movq %r14, %rdi
movl $0x5b, %esi
callq 0x4150
cmpq %rax, %r15
jne 0xe041
movq %r14, %rdi
movl $0x3d, %esi
callq 0x4130
xorl %ecx, %ecx
testq %rax, %rax
cmovneq %rcx, %rbx
jmp 0xe043
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: do_hidden
void
do_hidden(FILE *fd)
{	Fcts *g;

	if (suppress)
		return;

	for (g = modex_hidden; g; g = g->nxt)
	{
		if (g->purged)
		{	continue;
		}
		g->purged = 1;

		if (g->derived)
		{	if (g->fc == 3		/* labelname */
			||  show_deps
			||  (!allprocs
			&&   strcmp(want, g->tg) != 0))
				continue;

			if (!(Verbose&2)
			&&  strcmp(g->tg, ":global:") == 0)
				continue;

			if (!Warnings)
				continue;

			fprintf(stderr, "%s: ", progname);
			if (g->lno > 0)
				fprintf(stderr, "line %3d, ", g->lno);

			switch (g->fc) {
			case 0:
				fprintf(stderr, "may need declaration for: ");
				break;
			case 1:	/* fct call */
				fprintf(stderr, "function call: ");
				break;
			case 2:
				fprintf(stderr, "initialize parameter: ");
				break;
			default:
				fprintf(stderr, "cannot happen fc ");
				break;
			}
			if (strcmp(g->dt, "Global") != 0)
				fprintf(stderr, "%s ", g->dt);
			fprintf(stderr, "%s (%s)\n", g->nm, g->tg);

		} else if (strcmp(g->dt, NONPRINT) != 0)
		{	fprintf(fd, "	c_code { %s %s; };	/*  %s */\n",
				g->dt, g->full?g->full:g->nm, NONSTATE);
	}	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2ac1f(%rip), %rax     # 0x38cc0
cmpl $0x0, (%rax)
setne %al
movq 0x2d302(%rip), %r14     # 0x3b3b0
testq %r14, %r14
sete %cl
orb %al, %cl
je 0xe0c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x1f44a(%rip), %r15     # 0x2d51b
leaq 0x2a998(%rip), %r12     # 0x38a70
leaq 0x2a989(%rip), %r13     # 0x38a68
cmpl $0x0, 0x20(%r14)
je 0xe0f1
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0xe0df
jmp 0xe0b8
movl $0x1, 0x20(%r14)
cmpl $0x0, 0x24(%r14)
je 0xe14f
cmpl $0x3, 0x30(%r14)
je 0xe0e6
cmpl $0x0, (%r12)
jne 0xe0e6
cmpl $0x0, (%r13)
je 0xe18e
leaq 0x2a960(%rip), %rax     # 0x38a7c
testb $0x2, (%rax)
jne 0xe135
movq 0x8(%r14), %rdi
leaq 0x160d0(%rip), %rsi     # 0x241fc
callq 0x41c0
testl %eax, %eax
je 0xe0e6
leaq 0x2a944(%rip), %rax     # 0x38a80
cmpl $0x0, (%rax)
je 0xe0e6
leaq 0x30(%r14), %rsi
movq %r14, %rdi
callq 0x48b3
jmp 0xe0e6
movq 0x10(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x41c0
testl %eax, %eax
je 0xe0e6
movq 0x18(%r14), %rcx
testq %rcx, %rcx
jne 0xe16e
movq (%r14), %rcx
movq %rbx, %rdi
leaq 0x160f1(%rip), %rsi     # 0x24269
movq %rbp, %rdx
leaq 0x16008(%rip), %r8      # 0x2418a
xorl %eax, %eax
callq 0x41d0
jmp 0xe0e6
leaq 0x28013(%rip), %rax     # 0x361a8
movq (%rax), %rdi
movq 0x8(%r14), %rsi
callq 0x41c0
testl %eax, %eax
jne 0xe0e6
jmp 0xe115
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: checkfull
char *
checkfull(char *r, char *s, int ln)
{	char *t = (char *) 0;
	char *nt, *z;

	if (s
	&& (t = strchr(s, '=')))	/* assigns t */
	{	nt = t;
		*t++ = '\0';
		while (*t == ' ' || *t == '\t')
			t++;
	}
	if (t && *t)
	{	z = nt = (char *) e_malloc(2*strlen(t)+1);

		if (strchr(t, ','))
			*z++ = '{';

		for ( ; *t; t++)
		{	if (*t == '\"')
				*z++ = '\\';
			*z++ = *t;
		}

		if (*nt == '{')
			*z++ = '}';

		*z = '\0';
		t = nt;
	}
	return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xe1e8
movq %rsi, %rdi
movl $0x3d, %esi
callq 0x4130
testq %rax, %rax
je 0xe1e8
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0xe1cf
cmpl $0x20, %eax
je 0xe1cf
testl %eax, %eax
jne 0xe1ed
movq %rbx, %r14
jmp 0xe250
xorl %r14d, %r14d
jmp 0xe250
movq %rbx, %rdi
callq 0x4110
leal 0x1(,%rax,2), %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x4130
movq %r14, %rcx
testq %rax, %rax
je 0xe235
movq %r14, %rcx
incq %rcx
movb $0x7b, (%r14)
jmp 0xe235
movb $0x5c, (%rcx)
incq %rcx
movb (%rbx), %al
movb %al, (%rcx)
incq %rcx
incq %rbx
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0xe225
testl %eax, %eax
jne 0xe22d
cmpb $0x7b, (%r14)
jne 0xe24d
movb $0x7d, (%rcx)
incq %rcx
movb $0x0, (%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: cleanse
void
cleanse(char *p)
{	char *z;

	while ((z = strstr(p, "\n")) != NULL)
		*z = ' ';

	while ((z = strstr(p, "\\n")) != NULL)
	{	*z++ = ' ';
		*z = ' ';
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %esi
callq 0x4130
testq %rax, %rax
je 0xe279
movb $0x20, (%rax)
movq %rbx, %rdi
jmp 0xe262
leaq 0x13f43(%rip), %rsi     # 0x221c3
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0xe2a9
leaq 0x13f2f(%rip), %r14     # 0x221c3
movw $0x2020, (%rax)         # imm = 0x2020
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xe294
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: imported
int
imported(char *p, char *q, int about_to_generate)
{	Spress *s;

	for (s = spress; s; s = s->nxt)
		if ((strcmp(q, s->pn) == 0
		||   strcmp(s->pn, "_all_") == 0)
		&&  (strcmp(p, s->vn) == 0
		||   strcmp(s->vn, "_all_") == 0))
		{	s->hit = 1;
			if (about_to_generate)
				return s->mustgen;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3054d(%rip), %rbp     # 0x3eaa0
xorl %ebx, %ebx
testq %rbp, %rbp
je 0xe5d2
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0x4(%rsp)
leaq 0x153b0(%rip), %r12     # 0x2391b
movq 0x8(%rbp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x41c0
testl %eax, %eax
je 0xe58d
movq %r13, %rdi
movq %r12, %rsi
callq 0x41c0
testl %eax, %eax
jne 0xe5af
movq (%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x41c0
testl %eax, %eax
je 0xe5ba
movq %r13, %rdi
movq %r12, %rsi
callq 0x41c0
testl %eax, %eax
je 0xe5ba
movq 0x20(%rbp), %rbp
testq %rbp, %rbp
jne 0xe56b
jmp 0xe5d2
movl $0x1, 0x10(%rbp)
cmpl $0x0, 0x4(%rsp)
je 0xe5cd
movl 0x14(%rbp), %ebx
jmp 0xe5d2
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_fnm
void
add_fnm(char *s)
{	NameL *nl;

	nl = (NameL *) e_malloc(sizeof(NameL));
	nl->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(nl->nm, s);
	nl->nxt = namel;
	namel = nl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2efcc(%rip), %rax     # 0x3d5e8
movq %rax, 0x10(%r14)
movq %r14, 0x2efc1(%rip)     # 0x3d5e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: vis_direct
void
vis_direct(char *s)	/* the gateway for generated model code */
{
	if (visu
	&& fp
	&& s
	&& !globals_only
	&& !show_deps
	&& !new_lut)
	{	handle_special(fp, s, "");
		if (strstr(s, "goto Return"))
			sawreturn++;
	}

	tbuf[0] = '\0';
}

// Assembly:
testq %rdi, %rdi
je 0xeb25
pushq %rbx
leaq 0x29f15(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0xeb24
movq %rdi, %rbx
movq 0x2a89e(%rip), %rdi     # 0x39370
testq %rdi, %rdi
je 0xeb24
leaq 0x2a1be(%rip), %rax     # 0x38c9c
cmpl $0x0, (%rax)
jne 0xeb24
leaq 0x29f86(%rip), %rax     # 0x38a70
cmpl $0x0, (%rax)
jne 0xeb24
leaq 0x2a1b6(%rip), %rax     # 0x38cac
cmpl $0x0, (%rax)
jne 0xeb24
leaq 0x1758f(%rip), %rdx     # 0x26091
movq %rbx, %rsi
callq 0xc2de
leaq 0x16081(%rip), %rsi     # 0x24b92
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0xeb24
incl 0x36680(%rip)           # 0x451a4
popq %rbx
movb $0x0, 0x2ead4(%rip)     # 0x3d600
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: x_scopetab
void
x_scopetab(scopetab_t *that, FILE *fpp, char *want)
{	scopetab_t *z;
	int j;

	if (that->htab && that->level > 3)
	for (z = that->parent; z; z = z->parent)
		if (z->owner && strcmp(z->owner, "-") != 0
		&&  z->owner_t == TN_FUNC_DEF
		&&  strcmp(z->owner, want) == 0)
		{	x_hashtab(that->htab, fpp);
			break;
		}

	for (j=0; j < that->nchild; j++)
		x_scopetab(that->children[j], fpp, want);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0xeb90
cmpl $0x4, 0x4(%r15)
jl 0xeb90
movq 0x10(%r15), %r13
testq %r13, %r13
je 0xeb90
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xeb7f
cmpb $0x2d, (%rdi)
jne 0xeb6c
cmpb $0x0, 0x1(%rdi)
je 0xeb7f
cmpl $0x1, 0x20(%r13)
jne 0xeb7f
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0xeb85
movq 0x10(%r13), %r13
jmp 0xeb53
movq %r12, %rdi
movq %r14, %rsi
callq 0x14bb1
cmpl $0x0, 0x28(%r15)
jle 0xebb9
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xeb2d
incq %r12
movslq 0x28(%r15), %rax
cmpq %rax, %r12
jl 0xeb9a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_doprops
void
ax_doprops(FILE *fd, scopetab_t *that)
{	Ax_Props *p;

	if (ax_prop_nr == 0) return;

	ax_fixed(fd);

	for (p = all_props; p; p = p->nxt)
	{	ax_decorate(that, p->n);	/* redundant? */
		ax_proposition(fd, p);
	}
}

// Assembly:
cmpl $0x0, 0x37806(%rip)     # 0x463d0
je 0xec0a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x148b0
movq 0x377f5(%rip), %r15     # 0x463d8
testq %r15, %r15
je 0xec05
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x14aca
movq %r14, %rdi
movq %r15, %rsi
callq 0x1480c
movq 0x20(%r15), %r15
jmp 0xebe3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: def_inc_spn
void
def_inc_spn(FILE *fd)
{	NameL *nl;

	for (nl = namel; nl; nl = nl->nxt)
		if (strstr(nl->nm, ".pml"))
			fprintf(fd, "#include \"%s\"\n", nl->nm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x2e7e7(%rip), %r13     # 0x3d5e8
testq %r13, %r13
je 0xee44
movq %rdi, %rbx
leaq 0x15781(%rip), %r14     # 0x24591
leaq 0x1577f(%rip), %r15     # 0x24596
movq (%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xee3b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41d0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0xee17
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: new_globchan
void
new_globchan(char *s)
{	NameL *nl;

	nl = (NameL *) e_malloc(sizeof(NameL));
	nl->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(nl->nm, s);
	nl->nxt = globchans;
	globchans = nl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2f7f9(%rip), %rax     # 0x3e680
movq %rax, 0x10(%r14)
movq %r14, 0x2f7ee(%rip)     # 0x3e680
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_imported
void
add_imported(char *p, char *q, int mustgenerate)
{	Spress *s;

	for (s = spress; s; s = s->nxt)
	{	if (strcmp(p, s->vn) == 0
		&&  strcmp(q, s->pn) == 0)
		{	return;
	}	}

	s = (Spress *) e_malloc(sizeof(Spress));
	s->vn = (char *) e_malloc(strlen(p)+1);
	s->pn = (char *) e_malloc(strlen(q)+1);
	strcpy(s->vn, p);
	strcpy(s->pn, q);
	s->hit = 0;
	s->mustgen = mustgenerate;
	s->nxt = spress;
	spress = s;

	if (strcmp(p, "_all_") == 0
	&&  strcmp(q, "_all_") == 0)
	{	import_all++;
	}

if (0) fprintf(stderr, "add imported %s %s %d\n", p, q, mustgenerate);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2f6ba(%rip), %r15     # 0x3eaa0
testq %r15, %r15
je 0xf414
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xf40e
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0xf4a9
movq 0x20(%r15), %r15
jmp 0xf3e6
movl $0x28, %edi
callq 0x6321
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r15)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x40b0
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x10(%r15)
movl %ebp, 0x14(%r15)
movq 0x2f62e(%rip), %rax     # 0x3eaa0
movq %rax, 0x20(%r15)
movq %r15, 0x2f623(%rip)     # 0x3eaa0
leaq 0x14497(%rip), %rsi     # 0x2391b
movq %r14, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xf4a9
leaq 0x14484(%rip), %rsi     # 0x2391b
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xf4a9
incl 0x2f5eb(%rip)           # 0x3ea94
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: do_parameters
void
do_parameters(void)
{	Fcts *g;
	char *z;
	char xx[128];

	if (suppress || globals_only)
	{	return;
	}

	for (g = modex_locals; g; g = g->nxt)
	{	if (g->fc == 2 && strcmp(fct_name, g->tg) == 0)
		{	if (!spintype(g->dt, g->full?g->full:g->nm))
			{	/* at least one param not spin mappable */
				if (Verbose)
				{	fprintf(stderr, "params of %s converted to local vars\n",
						g->tg);
				}
				return;
	}	}	}

	for (g = modex_locals; g; g = g->nxt)
	{	if (strcmp(fct_name, g->tg) == 0
		&&  g->fc == 2)	/* spin-mappable formal params */
		{	z = spintype(g->dt, g->full?g->full:g->nm);
			if (z)
			{	if (did_parameters)
				{	vis_direct(", ");
				}
				if (strcmp(wanttype, "inline") == 0)
				{	sprintf(xx, "%s", g->full?g->full:g->nm);
				} else
				{	sprintf(xx, "%s %s", z, g->full?g->full:g->nm);
				}
				vis_direct(xx);
				did_parameters = 1;
	}	}	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x297f4(%rip), %rax     # 0x38cc0
leaq 0x297c9(%rip), %rcx     # 0x38c9c
movl (%rcx), %ecx
orl (%rax), %ecx
jne 0xf625
movq 0x2beec(%rip), %r12     # 0x3b3d0
testq %r12, %r12
je 0xf625
leaq 0x26e9c(%rip), %rbx     # 0x36390
movq %r12, %r15
cmpl $0x2, 0x30(%r15)
jne 0xf52f
movq 0x8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41c0
testl %eax, %eax
jne 0xf52f
movq 0x18(%r15), %rsi
testq %rsi, %rsi
jne 0xf51d
movq (%r15), %rsi
movq 0x10(%r15), %rdi
callq 0xdf6b
testq %rax, %rax
je 0xf619
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xf4f7
testq %r12, %r12
je 0xf625
leaq 0x26e48(%rip), %rbx     # 0x36390
leaq 0x26c69(%rip), %r13     # 0x361b8
leaq 0x13d64(%rip), %r14     # 0x232ba
movq %rsp, %r15
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xf609
cmpl $0x2, 0x30(%r12)
jne 0xf609
movq 0x18(%r12), %rsi
testq %rsi, %rsi
jne 0xf588
movq (%r12), %rsi
movq 0x10(%r12), %rdi
callq 0xdf6b
testq %rax, %rax
je 0xf609
movq %rax, %rbp
cmpl $0x0, 0x2f4ef(%rip)     # 0x3ea90
je 0xf5af
leaq 0x14c68(%rip), %rdi     # 0x24212
callq 0xeab6
movq (%r13), %rdi
movq %r14, %rsi
callq 0x41c0
movq 0x18(%r12), %rcx
testl %eax, %eax
je 0xf5e3
testq %rcx, %rcx
jne 0xf5cd
movq (%r12), %rcx
movq %r15, %rdi
leaq 0x15179(%rip), %rsi     # 0x24750
movq %rbp, %rdx
xorl %eax, %eax
callq 0x42a0
jmp 0xf5f7
testq %rcx, %rcx
jne 0xf5ec
movq (%r12), %rcx
movq %r15, %rdi
movq %rcx, %rsi
callq 0x40b0
movq %r15, %rdi
callq 0xeab6
movl $0x1, 0x2f487(%rip)     # 0x3ea90
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xf559
jmp 0xf625
leaq 0x2945c(%rip), %rax     # 0x38a7c
cmpl $0x0, (%rax)
jne 0xf637
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x269ba(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x150e2(%rip), %rsi     # 0x2472a
movq %r14, %rdx
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: map_type
int
map_type(char *s, symentry_t *nmtbl)
{	Fcts *f = (Fcts *) 0;
	int ret_val = 0;	/* 0 = undefined */

	if (nmtbl->kind == ENUM_CONST_ENTRY && is_constant(s))
	{	ret_val = 3;	/* same as hidden */
		goto done;
	}

	if (nmtbl->kind != VARDECL_ENTRY)
		goto shortcut;
	/* else its a typedef, structname, fctname, labelname */

	/* local */
	for (f = modex_locals; f; f = f->nxt)
	{	if (strcmp(s, f->nm) == 0
		&&  strcmp(fct_name, f->tg) == 0)
		{	if (strcmp(fct_name, want) == 0)
				f->wanted = 1;
			if (!imported(s, f->tg, 0))
				ret_val = 3;
			else
				ret_val = 1;
			goto done;
	}	}

	/* global */
	for (f = modex_globals; f; f = f->nxt)
	{	if (strcmp(s, f->nm) == 0)
		{	if (!imported(s, "Global", 0))
				ret_val = 3;
			else
				ret_val = 2;
			goto done;
	}	}
shortcut:
	/* hidden */
	for (f = modex_hidden; f; f = f->nxt)
	{	if (strcmp(f->dt, "Global") != 0	/* structure member */
		&&  strcmp(s, f->nm) == 0)
		{	ret_val = 3;
			goto done;
	}	}

done:
#if 0
	if (visu && check_type && ret_val)
	{	if (f				/* was missing, found by uno 10/18/01 */
		&&  strcmp(f->dt, "int") != 0
		&&  strcmp(f->dt, "int ") != 0
		&&  strcmp(f->dt, "short") != 0
		&&  strcmp(f->dt, "short ") != 0)
		{	fprintf(stderr, "%s: %d: error, return var %s must be int (saw %s)\n",
				progname, f->lno, s, f->dt);
	}	}
#endif
	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x4, %eax
jne 0xfa6e
movq %rsi, %r14
movq %rbx, %rdi
callq 0x7591
movl $0x3, %ebp
testl %eax, %eax
jne 0xfb7c
movl (%r14), %eax
cmpl $0x3, %eax
jne 0xfad9
movq 0x2b956(%rip), %r12     # 0x3b3d0
testq %r12, %r12
je 0xfab8
leaq 0x2690a(%rip), %r14     # 0x36390
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xfaae
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x41c0
testl %eax, %eax
je 0xfb3e
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xfa86
movq 0x2b909(%rip), %r14     # 0x3b3c8
testq %r14, %r14
je 0xfad9
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0xfb23
movq 0x38(%r14), %r14
jmp 0xfabf
movq 0x2b8d0(%rip), %r15     # 0x3b3b0
xorl %ebp, %ebp
testq %r15, %r15
je 0xfb7c
leaq 0x125c4(%rip), %r14     # 0x220b6
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x41c0
testl %eax, %eax
je 0xfb11
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0xfb1c
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xfaf2
jmp 0xfb7c
movl $0x3, %ebp
jmp 0xfb7c
leaq 0x1258c(%rip), %rsi     # 0x220b6
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe541
cmpl $0x1, %eax
adcl $0x2, %ebp
jmp 0xfb7c
leaq 0x26663(%rip), %rax     # 0x361a8
movq (%rax), %rsi
leaq 0x26841(%rip), %rdi     # 0x36390
callq 0x41c0
testl %eax, %eax
jne 0xfb61
movl $0x1, 0x28(%r12)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xe541
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x1(,%rcx,2), %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: dump_substitute
void
dump_substitute(FILE *fd)
{	Fcts *f;
	for (f = maps; f; f = f->nxt)
	{	if (f->level > 0)
			continue;
		if (f->tg)
			fprintf(fd, "Substitute	%s	%s\n", f->nm, f->tg);
		else
			fprintf(fd, "Substitute	%s\n", f->nm);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x2b812(%rip), %r12     # 0x3b3a8
testq %r12, %r12
je 0xfbe5
movq %rdi, %rbx
leaq 0x14cb3(%rip), %r14     # 0x24858
leaq 0x14c9a(%rip), %r15     # 0x24846
cmpl $0x0, 0x2c(%r12)
jg 0xfbdb
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rbx, %rdi
testq %rcx, %rcx
je 0xfbd1
movq %r15, %rsi
xorl %eax, %eax
callq 0x41d0
jmp 0xfbdb
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xfbac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: via_substitute
void
via_substitute(char *into, char *z)
{	char *q, nbuf[BigEnough];
	Fcts *f;
if (0) fprintf(stderr, "via_sub '%s'\n", into);
	strcpy(into, z);

	if (in_args)
	{	q = z;
		while (*q == ' ')
			q++;
		if (strncmp(q, "void", strlen("void")) == 0)
		{	q += strlen("void");
			while (*q == ' ' || *q == '*')
				q++;
			if (*q == '\0')
			{	strcpy(into, "");
				return;	/* e.g.: main(void *) */
		}	}
	}

	for (f = maps; f; f = f->nxt)
	while ((q = strstr(into, f->nm)) != NULL)
	{	*q = '\0';
		strcpy(nbuf, into);
		if (f->tg) strcat(nbuf, f->tg);
		strcat(nbuf, &q[strlen(f->nm)]);
		strcpy(into, nbuf);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40b0
cmpl $0x0, 0x2b7ab(%rip)     # 0x3b3bc
je 0xfc5c
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0xfc16
leaq 0x14460(%rip), %rsi     # 0x24088
movl $0x4, %edx
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
jne 0xfc5c
addq $0x4, %r14
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0xfc4b
cmpl $0x2a, %eax
jne 0xfc50
incq %r14
jmp 0xfc3d
testl %eax, %eax
jne 0xfc5c
movb $0x0, (%rbx)
jmp 0xfce0
movq 0x2b745(%rip), %r12     # 0x3b3a8
testq %r12, %r12
je 0xfce0
movq %rsp, %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0xfcd6
movq %rax, %r15
movb $0x0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x8(%r12), %rsi
testq %rsi, %rsi
je 0xfca0
movq %r14, %rdi
callq 0x4290
movq (%r12), %rdi
callq 0x4110
addq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40b0
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x42d0
movq %rax, %r15
testq %rax, %rax
jne 0xfc7f
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xfc6b
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: add_external
void
add_external(char *p, char *q)
{	Spress *s;

	for (s = externals; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0
		&&  strcmp(q, s->pn) == 0)
			return;
	s = (Spress *) e_malloc(sizeof(Spress));
	s->vn = (char *) e_malloc(strlen(p)+1);
	s->pn = (char *) e_malloc(strlen(q)+1);
	strcpy(s->vn, p);
	strcpy(s->pn, q);
	s->hit = 0;
	s->nxt = externals;
	externals = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2eda7(%rip), %r15     # 0x3eaa8
testq %r15, %r15
je 0xfd2b
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41c0
testl %eax, %eax
jne 0xfd25
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0xfd90
movq 0x20(%r15), %r15
jmp 0xfd01
movl $0x28, %edi
callq 0x6321
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r15)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x40b0
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x10(%r15)
movq 0x2ed23(%rip), %rax     # 0x3eaa8
movq %rax, 0x20(%r15)
movq %r15, 0x2ed18(%rip)     # 0x3eaa8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: nextarg
char*
nextarg(char *p)
{
	while (*p && /* *p != ' ' && */ *p != '\t')
		p++;
	while (*p == ' ' || *p == '\t')
		*p++ = 0;
	return p;
}

// Assembly:
movq %rdi, %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0xfdb3
testl %ecx, %ecx
je 0xfdb3
incq %rax
jmp 0xfd99
movb $0x0, (%rax)
movb 0x1(%rax), %cl
incq %rax
cmpb $0x20, %cl
je 0xfdaa
movzbl %cl, %ecx
cmpl $0x9, %ecx
je 0xfdaa
retq