LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: get_defaults
void
get_defaults(char *lut)
{	Cache *c;

	for (c = cache; c; c = c->nxt)
		c->hit |= 5;		/* mark */

	if (ulut)
	{	get_lut("", ulut);	/* once */
		ulut = 0;
	}

	Down++;
	if (strcmp(lut, GLOBAL_LUT) != 0)
		get_lut("", GLOBAL_LUT);
	Down++;
	get_lut("", DEFAULT_LUT);	/* loaded last - lowest priority */

	Down -= 2;

	for (c = cache; c; c = c->nxt)
	{	if (c->hit & 5)
			c->hit &= ~5;	/* unmark */
		else
			c->hit = 1;	/* consider hit */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3a1a5(%rip), %rax     # 0x4dc88
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13b09
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
orl $0x5, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13ae7
leaq 0x34370(%rip), %rax     # 0x47e80
cmpq $0x0, (%rax)
je 0x13b3a
leaq 0x34363(%rip), %rax     # 0x47e80
movq (%rax), %rsi
leaq 0x23997(%rip), %rdi     # 0x374be
callq 0x12860
leaq 0x3434d(%rip), %rax     # 0x47e80
movq $0x0, (%rax)
movl 0x36a20(%rip), %eax     # 0x4a560
addl $0x1, %eax
movl %eax, 0x36a17(%rip)     # 0x4a560
movq -0x8(%rbp), %rdi
leaq 0x22256(%rip), %rsi     # 0x35daa
callq 0x4180
cmpl $0x0, %eax
je 0x13b71
leaq 0x23959(%rip), %rdi     # 0x374be
leaq 0x2223e(%rip), %rsi     # 0x35daa
callq 0x12860
movl 0x369e9(%rip), %eax     # 0x4a560
addl $0x1, %eax
movl %eax, 0x369e0(%rip)     # 0x4a560
leaq 0x23937(%rip), %rdi     # 0x374be
leaq 0x22228(%rip), %rsi     # 0x35db6
callq 0x12860
movl 0x369c7(%rip), %eax     # 0x4a560
subl $0x2, %eax
movl %eax, 0x369be(%rip)     # 0x4a560
movq 0x3a0df(%rip), %rax     # 0x4dc88
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13bed
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x5, %eax
cmpl $0x0, %eax
je 0x13bd2
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
andl $-0x6, %ecx
movl %ecx, 0x14(%rax)
jmp 0x13bdd
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x13bdf
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13bad
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: add_padding
void
add_padding(FILE *lf, char *s)
{	int j;
	j = strlen(s);
	if (j < 40) fprintf(lf, "\t");
	if (j < 32) fprintf(lf, "\t");
	if (j < 24) fprintf(lf, "\t");
	if (j < 16) fprintf(lf, "\t");
	if (j <  8) fprintf(lf, "\t");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movl %eax, -0x14(%rbp)
cmpl $0x28, -0x14(%rbp)
jge 0x13c34
movq -0x8(%rbp), %rdi
leaq 0x23890(%rip), %rsi     # 0x374bd
movb $0x0, %al
callq 0x4190
cmpl $0x20, -0x14(%rbp)
jge 0x13c4c
movq -0x8(%rbp), %rdi
leaq 0x23878(%rip), %rsi     # 0x374bd
movb $0x0, %al
callq 0x4190
cmpl $0x18, -0x14(%rbp)
jge 0x13c64
movq -0x8(%rbp), %rdi
leaq 0x23860(%rip), %rsi     # 0x374bd
movb $0x0, %al
callq 0x4190
cmpl $0x10, -0x14(%rbp)
jge 0x13c7c
movq -0x8(%rbp), %rdi
leaq 0x23848(%rip), %rsi     # 0x374bd
movb $0x0, %al
callq 0x4190
cmpl $0x8, -0x14(%rbp)
jge 0x13c94
movq -0x8(%rbp), %rdi
leaq 0x23830(%rip), %rsi     # 0x374bd
movb $0x0, %al
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: dump_lut
void
dump_lut(void)
{	int n;
	FILE *lf;
	char nlutfl[512];
	static char *prefs[] =
	{ "D: ", "C: ", "A: ", "F: ", "R: ", "case ", "", 0 };

	sprintf(nlutfl, "%s.%s", want, suffix);
	if (1 || Verbose_cmds)
		fprintf(stderr, "%s: writing %s\n", progname, nlutfl);

	if ((lf = fopen(nlutfl, MFLAGS)) == NULL)
	{	fprintf(stderr, "%s: cannot create %s\n", progname, nlutfl);
		return;
	}
if (debug_io) fprintf(stderr, "open %s -> %p\n", nlutfl, lf);
	fprintf(lf, "%s for target <%s>\n", Banner, want);
	dump_fct(lf);
	dump_substitute(lf);

	if (Verbose&2)
		dump_decls(stdout);

	for (n = 0; prefs[n]; n++)
		trav_lut(lf, prefs[n]);
if (debug_io) fprintf(stderr, "close v %p\n", lf);
	Fclose(lf);
	add_fnm(nlutfl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
leaq -0x210(%rbp), %rdi
leaq 0x3121f(%rip), %rax     # 0x45178
movq (%rax), %rdx
leaq 0x31205(%rip), %rax     # 0x45168
movq (%rax), %rcx
leaq 0x21e84(%rip), %rsi     # 0x35df1
movb $0x0, %al
callq 0x4260
movq 0x3107d(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x311eb(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq -0x210(%rbp), %rcx
leaq 0x21e61(%rip), %rsi     # 0x35df7
movb $0x0, %al
callq 0x4190
leaq -0x210(%rbp), %rdi
leaq 0x26e04(%rip), %rsi     # 0x3adaf
callq 0x4230
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x13fe8
movq 0x31037(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x311a5(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq -0x210(%rbp), %rcx
leaq 0x21e2b(%rip), %rsi     # 0x35e07
movb $0x0, %al
callq 0x4190
jmp 0x140e5
leaq 0x33bf9(%rip), %rax     # 0x47be8
cmpl $0x0, (%rax)
je 0x14017
movq 0x30ffd(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq -0x210(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x216e0(%rip), %rsi     # 0x356f0
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rdi
leaq 0x31156(%rip), %rax     # 0x45178
movq (%rax), %rcx
leaq 0x20a86(%rip), %rsi     # 0x34ab2
leaq 0x20a93(%rip), %rdx     # 0x34ac6
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0xcee0
movq -0x10(%rbp), %rdi
callq 0x12210
leaq 0x33bf9(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1406c
movq 0x30f6c(%rip), %rax     # 0x44fd0
movq (%rax), %rdi
callq 0xf8b0
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x31a72(%rip), %rax     # 0x45af0
cmpq $0x0, (%rax,%rcx,8)
je 0x140a8
movq -0x10(%rbp), %rdi
movslq -0x4(%rbp), %rcx
leaq 0x31a5c(%rip), %rax     # 0x45af0
movq (%rax,%rcx,8), %rsi
callq 0x13ca0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x14073
leaq 0x33b39(%rip), %rax     # 0x47be8
cmpl $0x0, (%rax)
je 0x140d0
movq 0x30f3d(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x21d54(%rip), %rsi     # 0x35e1d
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0x6d20
leaq -0x210(%rbp), %rdi
callq 0x10500
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: check_lut
void
check_lut(FILE *fd)
{	Cache *c;
	int identified = 0;

	if (!cache)
		fprintf(fd, "%s: empty lookup table\n", progname);

	for (c = cache; c; c = c->nxt)
		if (!c->hit)
		{	if (!identified)
			{	fprintf(fd, "<%s>:\n", want);
				identified = 1;
			}
			fprintf(fd, "Redundant: %s\t%s\n",
				c->s, c->t);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, 0x39b7d(%rip)     # 0x4dc88
jne 0x14129
movq -0x8(%rbp), %rdi
leaq 0x31058(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq 0x21d07(%rip), %rsi     # 0x35e29
movb $0x0, %al
callq 0x4190
movq 0x39b58(%rip), %rax     # 0x4dc88
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1419f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x1418f
cmpl $0x0, -0x14(%rbp)
jne 0x1416e
movq -0x8(%rbp), %rdi
leaq 0x31022(%rip), %rax     # 0x45178
movq (%rax), %rdx
leaq 0x21ce1(%rip), %rsi     # 0x35e41
movb $0x0, %al
callq 0x4190
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x21cc0(%rip), %rsi     # 0x35e48
movb $0x0, %al
callq 0x4190
jmp 0x14191
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x14134
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: modex_mark
void
modex_mark(treenode *n, int how)
{
	if (!n || !n->hdr.defuse) return;

	if (Verbose&2)
	{	sprintf(tbuf, " /* [%d] ", how);
		vis_direct(tbuf);
		dump_defuse(n->hdr.defuse, 0, stdout);
	}
	mark_defs(n->hdr.defuse, how, stderr);

	if (Verbose&2) vis_direct(" */ ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x141e1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x141e6
jmp 0x1426b
leaq 0x33a5f(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14234
movl -0xc(%rbp), %edx
leaq 0x385cf(%rip), %rdi     # 0x4c7d0
leaq 0x21c52(%rip), %rsi     # 0x35e5a
movb $0x0, %al
callq 0x4260
leaq 0x385ba(%rip), %rdi     # 0x4c7d0
callq 0x10b40
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x30da6(%rip), %rax     # 0x44fd0
movq (%rax), %rdx
xorl %esi, %esi
callq 0x2db30
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq 0x30db2(%rip), %rax     # 0x44ff8
movq (%rax), %rdx
callq 0x2d990
leaq 0x339f7(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1426b
leaq 0x21de6(%rip), %rdi     # 0x3604c
callq 0x10b40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: form_c_tag
char *
form_c_tag(char *frst, int i, char *lst)
{	char *p;
	int j = strlen(frst)+strlen(OutBuf)-i+strlen(lst)+strlen(" }")+1;
	p = (char *) e_malloc(j*sizeof(char));
	sprintf(p, "%s%s%s }", frst, &OutBuf[i], lst);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, -0x38(%rbp)
leaq 0x342a9(%rip), %rdi     # 0x48550
callq 0x40f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
addq $0x2, %rax
addq $0x1, %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
movslq -0xc(%rbp), %rax
leaq 0x3424b(%rip), %rcx     # 0x48550
addq %rax, %rcx
movq -0x18(%rbp), %r8
leaq 0x21b51(%rip), %rsi     # 0x35e64
movb $0x0, %al
callq 0x4260
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: do_mine
void
do_mine(SymList *s)
{	char mine[BigEnough];
	if (s->mark)
	{	sprintf(mine, "	%s = %s | %d;\n",
			s->sm->nme->str,
			s->sm->nme->str,
			s->mark&(DEF|USE|
			FCALL|REF0|REF1|REF2|DEREF|
			ALIAS|ARRAY_DECL|HIDE|DECL|
			USEafterdef|USEbeforedef|PARAM));
		vis_direct(mine);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x14399
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
andl $0x3fff, %r8d           # imm = 0x3FFF
leaq 0x21ae7(%rip), %rsi     # 0x35e6d
movb $0x0, %al
callq 0x4260
leaq -0x1010(%rbp), %rdi
callq 0x10b40
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: do_dumode
char *
do_dumode(treenode *n)
{	SymList *s;

	if (in_call || in_args || in_pars)
		goto out;

	if (!n)
	{	vis_direct("/* --no node-- */\n");
		abort();
	} else
	{	if (!n->hdr.defuse)
			return "comment";
	}

	for (s = n->hdr.defuse->def; s; s = s->nxt)
		do_mine(s);
	for (s = n->hdr.defuse->use; s; s = s->nxt)
		do_mine(s);
	for (s = n->hdr.defuse->other; s; s = s->nxt)
		do_mine(s);
out:
	return "comment";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x361c9(%rip)     # 0x4a58c
jne 0x143d7
cmpl $0x0, 0x361c4(%rip)     # 0x4a590
jne 0x143d7
cmpl $0x0, 0x398c7(%rip)     # 0x4dc9c
je 0x143dc
jmp 0x1449d
cmpq $0x0, -0x10(%rbp)
jne 0x143f4
leaq 0x21a93(%rip), %rdi     # 0x35e7d
callq 0x10b40
callq 0x4050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1440f
leaq 0x266a8(%rip), %rax     # 0x3aaae
movq %rax, -0x8(%rbp)
jmp 0x144a8
jmp 0x14411
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1443f
movq -0x18(%rbp), %rdi
callq 0x14330
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x14421
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1446d
movq -0x18(%rbp), %rdi
callq 0x14330
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1444f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1449b
movq -0x18(%rbp), %rdi
callq 0x14330
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1447d
jmp 0x1449d
leaq 0x2660a(%rip), %rax     # 0x3aaae
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: replace_lut
static void
replace_lut(char *r, char *t)
{	Cache *c;

	for (c = cache; c; c = c->nxt)
		if (strcmp(c->s, r) == 0
		&&  strlen(c->s) == strlen(r))
		{	c->t = (char *) e_malloc(strlen(t)+1);
			if (Verbose&2)
				printf("%s: replacing %s -> %s -> %s\n", progname, r, c->t, t);
			strcpy(c->t, t);
			return;
		}

	printf("%s: no lut entry for %s\n", progname, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x38e41(%rip), %rax     # 0x4dc88
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14f12
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x14eff
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x14eff
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x32d92(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14eec
leaq 0x302a5(%rip), %rax     # 0x45170
movq (%rax), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %r8
leaq 0x21a9d(%rip), %rdi     # 0x36982
movb $0x0, %al
callq 0x4120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
jmp 0x14f2e
jmp 0x14f01
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x14e4b
leaq 0x30257(%rip), %rax     # 0x45170
movq (%rax), %rsi
movq -0x8(%rbp), %rdx
leaq 0x21a79(%rip), %rdi     # 0x369a0
movb $0x0, %al
callq 0x4120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: precondition
void
precondition(treenode *n)
{	PreC *p;

	p = (PreC *) e_malloc(sizeof(PreC));
	p->n = n;
	p->nxt = prec;
	prec = p;
if (0) fprintf(fp, "add prec\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x3bf0c(%rip), %rcx     # 0x50ed8
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x3bef9(%rip)     # 0x50ed8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: act_prec
void
act_prec(void)
{	PreC *p;
#if 0
	if (!prec)
	{	strcpy(PreBuf, "");
		return;
	}
#endif
if (0) fprintf(fp, "act prec\n");
	strcpy(Rem, OutBuf);	/* save */
	strcpy(OutBuf, "");

	for (p = prec; p; p = p->nxt)
	{	modex_recur(p->n);
		if (p->nxt)
		{	strcat(OutBuf, " && ");
	}	}
	if (strlen(OutBuf) > 0
	&&  strlen(Bounds) > 0)
	{	strcat(OutBuf, " && ");
	}
	strcat(OutBuf, Bounds);

if (0) fprintf(fp, " [[[ (%s) <==> [%s] ]]] ", OutBuf, Rem);

	strcpy(PreBuf, OutBuf);
	strcpy(OutBuf, Rem);	/* restore */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3bee1(%rip), %rdi     # 0x50ee0
leaq 0x3354a(%rip), %rsi     # 0x48550
callq 0x40a0
leaq 0x3353e(%rip), %rdi     # 0x48550
leaq 0x224a5(%rip), %rsi     # 0x374be
callq 0x40a0
movq 0x3beb3(%rip), %rax     # 0x50ed8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1506a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xadb0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1505a
leaq 0x33502(%rip), %rdi     # 0x48550
leaq 0x2039a(%rip), %rsi     # 0x353ef
callq 0x4250
jmp 0x1505c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15029
leaq 0x334df(%rip), %rdi     # 0x48550
callq 0x40f0
cmpq $0x0, %rax
jbe 0x150a1
leaq 0x3672d(%rip), %rdi     # 0x4b7b0
callq 0x40f0
cmpq $0x0, %rax
jbe 0x150a1
leaq 0x334bb(%rip), %rdi     # 0x48550
leaq 0x20353(%rip), %rsi     # 0x353ef
callq 0x4250
leaq 0x334a8(%rip), %rdi     # 0x48550
leaq 0x36701(%rip), %rsi     # 0x4b7b0
callq 0x4250
leaq 0x38bf5(%rip), %rdi     # 0x4dcb0
leaq 0x3348e(%rip), %rsi     # 0x48550
callq 0x40a0
leaq 0x33482(%rip), %rdi     # 0x48550
leaq 0x3be0b(%rip), %rsi     # 0x50ee0
callq 0x40a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: vis_print_d
void
vis_print_d(int d)
{	char nw[64];

	if (!visu) return;

	sprintf(nw, "%d", d);
	strcat(OutBuf, nw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq 0x3249e(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x15709
jmp 0x1572e
leaq -0x50(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x29589(%rip), %rsi     # 0x3eca0
movb $0x0, %al
callq 0x4260
leaq -0x50(%rbp), %rsi
leaq 0x32e27(%rip), %rdi     # 0x48550
callq 0x4250
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: vis_print_g
void
vis_print_g(double d)
{	char nw[64];

	if (!visu) return;

	sprintf(nw, "%g", d);
	strcat(OutBuf, nw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x3244c(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x1575b
jmp 0x15782
leaq -0x50(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
leaq 0x208f1(%rip), %rsi     # 0x3605c
movb $0x1, %al
callq 0x4260
leaq -0x50(%rbp), %rsi
leaq 0x32dd3(%rip), %rdi     # 0x48550
callq 0x4250
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: vis_print
void
vis_print(char *nw)
{	char w0[1024], *w1, *w2;

	if (!visu || !nw) return;

	/* avoid modifying the argument, because
	   it could be a fixed string, like "\n"
	   which may be read-only
	 */
	w1 = (char *) w0;
	strncpy(w1, nw, sizeof(w0));
	while ((w2 = strchr(w1, '\n')) != NULL)
	{	*w2 = '\0';
		strcat(OutBuf, w1);
		strcat(OutBuf, "\\");
		strcat(OutBuf, "n");
		*w2 = '\n';
		w1 = ++w2;
	}
	strcat(OutBuf, w1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq 0x323fa(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
je 0x157b2
cmpq $0x0, -0x8(%rbp)
jne 0x157b7
jmp 0x15876
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4080
movq -0x418(%rbp), %rdi
movl $0xa, %esi
callq 0x4110
movq %rax, -0x420(%rbp)
cmpq $0x0, %rax
je 0x15863
movq -0x420(%rbp), %rax
movb $0x0, (%rax)
movq -0x418(%rbp), %rsi
leaq 0x32d40(%rip), %rdi     # 0x48550
callq 0x4250
leaq 0x32d34(%rip), %rdi     # 0x48550
leaq 0x2087a(%rip), %rsi     # 0x3609d
callq 0x4250
leaq 0x32d21(%rip), %rdi     # 0x48550
leaq 0x1d99f(%rip), %rsi     # 0x331d5
callq 0x4250
movq -0x420(%rbp), %rax
movb $0xa, (%rax)
movq -0x420(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x420(%rbp)
movq %rax, -0x418(%rbp)
jmp 0x157da
movq -0x418(%rbp), %rsi
leaq 0x32cdf(%rip), %rdi     # 0x48550
callq 0x4250
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: vis_indent
void
vis_indent(int tb, char *s)	/* not via lookup table */
{	int j;

	if (!visu) return;

	for (j = tb-taboffset; j > 0; j--)
		vis_direct("  ");

	vis_direct(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3230a(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x1589d
jmp 0x158cf
movl -0x4(%rbp), %eax
subl 0x3c646(%rip), %eax     # 0x51eec
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x158c6
leaq 0x207a9(%rip), %rdi     # 0x3605f
callq 0x10b40
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x158a9
movq -0x10(%rbp), %rdi
callq 0x10b40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: check_fct
void
check_fct(char *s, int tabs)
{	Fcts *f;

	for (f = fcts; f; f = f->nxt)
		if (strstr(s, f->nm))
		{	vis_indent(tabs, "fct_");
			vis_direct(f->tg);
			vis_direct("();\n");	/* inline call */
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x34c72(%rip), %rax     # 0x4a568
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15951
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4280
cmpq $0x0, %rax
je 0x15941
movl -0xc(%rbp), %edi
leaq 0x20741(%rip), %rsi     # 0x36062
callq 0x15880
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10b40
leaq 0x217d2(%rip), %rdi     # 0x3710c
callq 0x10b40
jmp 0x15951
jmp 0x15943
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x158fa
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: push_dostack
void
push_dostack(treenode *tn)
{	char *nl;

	nl = (char *) e_malloc(16);
	sprintf(nl, "L_%d", do_uniq++);
	DoIncr[do_level] = tn;
	DoLabel[do_level++] = nl;
	vis_direct(nl);
	vis_direct(":\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl 0x3c56c(%rip), %edx     # 0x51ef0
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3c561(%rip)     # 0x51ef0
leaq 0x206d1(%rip), %rsi     # 0x36067
movb $0x0, %al
callq 0x4260
movq -0x8(%rbp), %rdx
movslq 0x32ba0(%rip), %rcx     # 0x48548
leaq 0x3c551(%rip), %rax     # 0x51f00
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movl 0x32b8b(%rip), %eax     # 0x48548
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x32b80(%rip)     # 0x48548
movslq %eax, %rcx
leaq 0x3c72e(%rip), %rax     # 0x52100
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x10b40
leaq 0x28e7b(%rip), %rdi     # 0x3e861
callq 0x10b40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: use_dostack
void
use_dostack(int tabs)
{
	if (do_level < 1 || do_level > MAXLEVEL)
	{	if (preview) return;
		fprintf(stderr, "dolevel error %d\n", do_level);
		exit(1);
	}

	if (DoIncr[do_level-1])
		modex_any(DoIncr[do_level-1], tabs);

	vis_indent(tabs, "goto ");
	vis_direct(DoLabel[do_level-1]);
	vis_direct(";\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, 0x32b36(%rip)     # 0x48548
jl 0x15a1d
cmpl $0x40, 0x32b2d(%rip)    # 0x48548
jle 0x15a56
leaq 0x321e8(%rip), %rax     # 0x47c0c
cmpl $0x0, (%rax)
je 0x15a2e
jmp 0x15ac6
movq 0x2f5c3(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movl 0x32b0a(%rip), %edx     # 0x48548
leaq 0x20627(%rip), %rsi     # 0x3606c
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movl 0x32aec(%rip), %eax     # 0x48548
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3c497(%rip), %rax     # 0x51f00
cmpq $0x0, (%rax,%rcx,8)
je 0x15a8f
movl 0x32ad2(%rip), %eax     # 0x48548
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3c47d(%rip), %rax     # 0x51f00
movq (%rax,%rcx,8), %rdi
movl -0x4(%rbp), %esi
callq 0x15ad0
movl -0x4(%rbp), %edi
leaq 0x205e5(%rip), %rsi     # 0x3607e
callq 0x15880
movl 0x32aa4(%rip), %eax     # 0x48548
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3c64f(%rip), %rax     # 0x52100
movq (%rax,%rcx,8), %rdi
callq 0x10b40
leaq 0x2164d(%rip), %rdi     # 0x3710e
callq 0x10b40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: modex_any
static void
modex_any(treenode *child, int tabs)
{
	if (!child)
	{
if (0) { printf("no child\n"); fflush(stdout); }
		return;
	}

if (0) printf("modex_any %d (%d = %s) %s, %s\n",
		tabs,
		child->hdr.tok, toksym(child->hdr.tok, 0),
		name_of_nodetype(child->hdr.which),
		name_of_node(child->hdr.type));

	switch (child->hdr.which){
	case NODE_T:
if (0) { printf("%d	>%d>%s>\n", count++, visu, OutBuf); fflush(stdout); }
		modex_node(child, tabs);
if (0) { printf("%d	<%d<%s<\n", --count, visu, OutBuf); fflush(stdout); }
		break;
	case LEAF_T:
		modex_leaf((leafnode *) child, tabs);
		break;
	case IF_T:
		modex_if((if_node *) child, tabs);
		break;
	case FOR_T:
		modex_for((for_node *) child, tabs);
		break;
	default:
		fprintf(stderr, "%s: error: unknown type %d\n",
			progname, child->hdr.which);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x15aeb
jmp 0x15b72
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x15b4a
movq -0x18(%rbp), %rax
leaq 0x1f45b(%rip), %rcx     # 0x34f64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x19900
jmp 0x15b72
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x16ed0
jmp 0x15b72
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x188d0
jmp 0x15b72
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1a330
jmp 0x15b72
movq 0x2f4a7(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2f615(%rip), %rax     # 0x45170
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x2191b(%rip), %rsi     # 0x37486
movb $0x0, %al
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: push_swstack
void
push_swstack(char *s)
{	char *nl;

	nl = (char *) e_malloc(strlen(s)+1);
	strcpy(nl, s);
	SwLabel[sw_level++] = nl;
	sw_first = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x10(%rbp), %rdx
movl 0x3b2f5(%rip), %eax     # 0x50ed0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x3b2ea(%rip)     # 0x50ed0
movslq %eax, %rcx
leaq 0x3b0e0(%rip), %rax     # 0x50cd0
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x3c702(%rip)     # 0x52300
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: use_swstack
void
use_swstack(void)
{
	if (sw_level < 0 || sw_level > MAXLEVEL)
	{	fprintf(stderr, "swlevel error\n");
		exit(1);
	}
	vis_print(SwLabel[sw_level-1]);
	sw_first++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x3b2b5(%rip)     # 0x50ed0
jl 0x15c26
cmpl $0x40, 0x3b2ac(%rip)    # 0x50ed0
jle 0x15c48
movq 0x2f3cb(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2044d(%rip), %rsi     # 0x36084
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movl 0x3b282(%rip), %eax     # 0x50ed0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3b075(%rip), %rax     # 0x50cd0
movq (%rax,%rcx,8), %rdi
callq 0x15790
movl 0x3c696(%rip), %eax     # 0x52300
addl $0x1, %eax
movl %eax, 0x3c68d(%rip)     # 0x52300
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: fputs_metachr
void
fputs_metachr(char c, int in_str)
{	char cstr[2];
	
	if (visu)
	switch (c) {
	case '\'': if (in_str) vis_print("'"); else vis_print("\\'"); break;
	case '"':  if (in_str) vis_print("\\\""); else vis_print("\""); break;
	case '\0': vis_print("\\0"); break;
	case '\\': vis_print("\\\\"); break;
	case '\n': vis_print("\\n"); break;
	case '\t': vis_print("\\t"); break;
	case '\r': vis_print("\\r"); break;
	case '\f': vis_print("\\f"); break;
	case '\b': vis_print("\\b"); break;
	case '\v': vis_print("\\v"); break;
	case '\a': vis_print("\\a"); break;
	default:   cstr[0] = c;
		   cstr[1] = '\0';
		   vis_print(cstr);
		   break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x31ee8(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
je 0x15dc8
movsbl -0x1(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5c, %eax
ja 0x15db3
movq -0x18(%rbp), %rax
leaq 0x1f295(%rip), %rcx     # 0x34f74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, -0x8(%rbp)
je 0x15cfc
leaq 0x24ca1(%rip), %rdi     # 0x3a996
callq 0x15790
jmp 0x15d08
leaq 0x20390(%rip), %rdi     # 0x36093
callq 0x15790
jmp 0x15dc6
cmpl $0x0, -0x8(%rbp)
je 0x15d21
leaq 0x2037c(%rip), %rdi     # 0x36096
callq 0x15790
jmp 0x15d2d
leaq 0x29674(%rip), %rdi     # 0x3f39c
callq 0x15790
jmp 0x15dc6
leaq 0x20360(%rip), %rdi     # 0x36099
callq 0x15790
jmp 0x15dc6
leaq 0x20352(%rip), %rdi     # 0x3609c
callq 0x15790
jmp 0x15dc6
leaq 0x1d47c(%rip), %rdi     # 0x331d4
callq 0x15790
jmp 0x15dc6
leaq 0x20339(%rip), %rdi     # 0x3609f
callq 0x15790
jmp 0x15dc6
leaq 0x2032e(%rip), %rdi     # 0x360a2
callq 0x15790
jmp 0x15dc6
leaq 0x20323(%rip), %rdi     # 0x360a5
callq 0x15790
jmp 0x15dc6
leaq 0x20318(%rip), %rdi     # 0x360a8
callq 0x15790
jmp 0x15dc6
leaq 0x2030d(%rip), %rdi     # 0x360ab
callq 0x15790
jmp 0x15dc6
leaq 0x20302(%rip), %rdi     # 0x360ae
callq 0x15790
jmp 0x15dc6
movb -0x1(%rbp), %al
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x15790
jmp 0x15dc8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: fputs_metastr
void
fputs_metastr(char *str)
{
	if (!visu) return;

	while (*str)
	{	fputs_metachr(*str,1);
		str++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x31dbd(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
jne 0x15dea
jmp 0x15e14
jmp 0x15dec
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x15e14
movq -0x8(%rbp), %rax
movl $0x1, %esi
movsbl (%rax), %edi
callq 0x15ca0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x15dec
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: doindent
void
doindent(int depth)
{	int i;

	if (Verbose&2)
	for (i = 0; i < depth; i++)
		fprintf(stderr, "  ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x31e1a(%rip), %rax     # 0x47c4c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15e70
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x15e6e
movq 0x2f1a6(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x20203(%rip), %rsi     # 0x3605f
movb $0x0, %al
callq 0x4190
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15e43
jmp 0x15e70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: saw_variable
void
saw_variable(int ln, int which)
{
if (0) fprintf(stderr, "XXX {%d} '%s' '%s'\n", which, dername, dertype);
	if (strlen(dername) == 0)
	{	strcpy(dername, Ldername);
	}
	if (strlen(dertype) == 0)
	{	strcpy(dertype, Ldertype);
	}

if (0)	fprintf(stderr, "%3d:========name%d: '%s' '%s' '%s' ('%s') [obuf: %s] decor %d\n",
		ln, which, derscope, dertype, dername, derproc, OutBuf, with_decorations);

	if (!with_decorations)
	{	if (strcmp(derscope, "Global") == 0)
		{	add_global(dertype, dername, 1, ln);
		} else
		{	add_local(dertype, dername, derproc, 1, ln, 40);
		}
	} else
	{	if (strcmp(derscope, "Global") == 0)
		{	add_full_global(dertype, dername, 1, ln);
		} else
		{	add_full_local(dertype, dername, derproc, 1, ln);
	}	}

//	strcpy(Ldername, dername);
//	strcpy(Ldertype, dertype);
//	fprintf(stderr, "zap_2222 <%s> %d\n", dername, decl_cnt);
//	strcpy(dername, "");
//	strcpy(dertype, "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x3471b(%rip), %rdi     # 0x4a5b0
callq 0x40f0
cmpq $0x0, %rax
jne 0x15eb3
leaq 0x34709(%rip), %rdi     # 0x4a5b0
leaq 0x3c462(%rip), %rsi     # 0x52310
callq 0x40a0
leaq 0x3c656(%rip), %rdi     # 0x52510
callq 0x40f0
cmpq $0x0, %rax
jne 0x15ed8
leaq 0x3c644(%rip), %rdi     # 0x52510
leaq 0x3c83d(%rip), %rsi     # 0x52710
callq 0x40a0
cmpl $0x0, 0x346c9(%rip)     # 0x4a5a8
jne 0x15f41
leaq 0x3ca28(%rip), %rdi     # 0x52910
leaq 0x1d1be(%rip), %rsi     # 0x330ad
callq 0x4180
cmpl $0x0, %eax
jne 0x15f16
movl -0x4(%rbp), %ecx
leaq 0x3c60d(%rip), %rdi     # 0x52510
leaq 0x346a6(%rip), %rsi     # 0x4a5b0
movl $0x1, %edx
callq 0xd440
jmp 0x15f3f
movl -0x4(%rbp), %r8d
leaq 0x3c5ef(%rip), %rdi     # 0x52510
leaq 0x34688(%rip), %rsi     # 0x4a5b0
leaq 0x3ca01(%rip), %rdx     # 0x52930
movl $0x1, %ecx
movl $0x28, %r9d
callq 0xf1c0
jmp 0x15f9b
leaq 0x3c9c8(%rip), %rdi     # 0x52910
leaq 0x1d15e(%rip), %rsi     # 0x330ad
callq 0x4180
cmpl $0x0, %eax
jne 0x15f76
movl -0x4(%rbp), %ecx
leaq 0x3c5ad(%rip), %rdi     # 0x52510
leaq 0x34646(%rip), %rsi     # 0x4a5b0
movl $0x1, %edx
callq 0xd6f0
jmp 0x15f99
movl -0x4(%rbp), %r8d
leaq 0x3c58f(%rip), %rdi     # 0x52510
leaq 0x34628(%rip), %rsi     # 0x4a5b0
leaq 0x3c9a1(%rip), %rdx     # 0x52930
movl $0x1, %ecx
callq 0xf560
jmp 0x15f9b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: istypedef
int
istypedef(treenode *n)
{	treenode *nn;

	for (nn = n; nn; nn = nn->lnode)
	{	if (nn->hdr.which == LEAF_T)
		{	break;
		}
		if (nn->hdr.type == TN_TYPE)
		{
//if (nn->hdr.tok == EXTRN)
// fprintf(stderr, "Mumble\n");
			switch (nn->hdr.tok) {
			case TYPEDEF:
 if (0)
 { printf("saw Typedef\n");
   print_tree(n, stdout);
 }
				return 1;
			case TYPEDEF_NAME:
 if (0)
 { printf("saw Typedef Name\n");
   print_tree(n, stdout);
 }
				break;
			case CHAR:	/* constant */
			case CHAR_CONST:
			case INUM:
			case RNUM:
			case STRING:
				break;
			}
		} else if (nn->hdr.type == TN_IDENT)
		{	break;
	}	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16059
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x15fd9
jmp 0x16059
movq -0x18(%rbp), %rax
cmpl $0x2e, 0x1c(%rax)
jne 0x16038
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x103, %eax            # imm = 0x103
je 0x16034
jmp 0x15ff6
movl -0x1c(%rbp), %eax
subl $0x105, %eax            # imm = 0x105
je 0x16032
jmp 0x16002
movl -0x1c(%rbp), %eax
addl $0xfffffef9, %eax       # imm = 0xFFFFFEF9
subl $0x3, %eax
jb 0x16034
jmp 0x16011
movl -0x1c(%rbp), %eax
subl $0x11c, %eax            # imm = 0x11C
je 0x16034
jmp 0x1601d
movl -0x1c(%rbp), %eax
subl $0x132, %eax            # imm = 0x132
jne 0x16036
jmp 0x16029
movl $0x1, -0x4(%rbp)
jmp 0x16060
jmp 0x16036
jmp 0x16036
jmp 0x16046
movq -0x18(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x16044
jmp 0x16059
jmp 0x16046
jmp 0x16048
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15fc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: precomputable
static int
precomputable(treenode *n)
{	int lft, rgt;

	if (!n) return 0;

	switch (n->hdr.tok) {
	case INUM:
		return ((leafnode *) n)->data.ival;
	case B_OR:
		lft = precomputable(n->lnode);
		rgt = precomputable(n->rnode);
		if (!lft || !rgt) return 0;
		return (lft|rgt);
	case B_AND:
		lft = precomputable(n->lnode);
		rgt = precomputable(n->rnode);
		if (!lft || !rgt) return 0;
		return (lft&rgt);
	default:
		fprintf(stderr, "modex: %s:%d unexpected token, precomputable '%s'\n",
			n->hdr.fnm, n->hdr.line, toksym(n->hdr.tok,0));
	case DOT:
	case ARROW:
	case IDENT:
		return 0;
	}
#if 0
	debug_node(n, 1, "");
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1608f
movl $0x0, -0x4(%rbp)
jmp 0x161ca
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x102, %eax            # imm = 0x102
je 0x161c3
jmp 0x160a6
movl -0x1c(%rbp), %eax
subl $0x108, %eax            # imm = 0x108
je 0x160e0
jmp 0x160b2
movl -0x1c(%rbp), %eax
subl $0x15e, %eax            # imm = 0x15E
je 0x160ef
jmp 0x160be
movl -0x1c(%rbp), %eax
subl $0x160, %eax            # imm = 0x160
je 0x16135
jmp 0x160ca
movl -0x1c(%rbp), %eax
addl $0xfffffe8b, %eax       # imm = 0xFFFFFE8B
subl $0x2, %eax
jb 0x161c3
jmp 0x16175
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x161ca
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16070
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x16070
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1611b
cmpl $0x0, -0x18(%rbp)
jne 0x16127
movl $0x0, -0x4(%rbp)
jmp 0x161ca
movl -0x14(%rbp), %eax
orl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x161ca
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16070
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x16070
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16161
cmpl $0x0, -0x18(%rbp)
jne 0x1616a
movl $0x0, -0x4(%rbp)
jmp 0x161ca
movl -0x14(%rbp), %eax
andl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x161ca
movq 0x2ee7c(%rip), %rax     # 0x44ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
xorl %esi, %esi
callq 0x1ab20
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl -0x20(%rbp), %ecx
movq %rax, %r8
leaq 0x207fd(%rip), %rsi     # 0x369b9
movb $0x0, %al
callq 0x4190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: derive_type
void
derive_type(char *s, treenode *n)
{
	strcpy(derscope, s);
	strcpy(dertype, "");
	strcpy(dername, "");
	dotree(n, 0, 1);	/* calls 'add_global' and 'add_local'
				 * to instantiate rewrite rules
				 */
	strcpy(derscope, s);
	strcpy(dertype, "");
	strcpy(dername, "");
	with_decorations = 1;	/* reproduce the full declarations */
	dotree(n, 0, 1);
	with_decorations = 0;	/* such as [] and '*' with initialization */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3c715(%rip), %rdi     # 0x52910
callq 0x40a0
leaq 0x3c309(%rip), %rdi     # 0x52510
leaq 0x212b0(%rip), %rsi     # 0x374be
callq 0x40a0
leaq 0x34396(%rip), %rdi     # 0x4a5b0
leaq 0x2129d(%rip), %rsi     # 0x374be
callq 0x40a0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xdf80
movq -0x8(%rbp), %rsi
leaq 0x3c6cf(%rip), %rdi     # 0x52910
callq 0x40a0
leaq 0x3c2c3(%rip), %rdi     # 0x52510
leaq 0x2126a(%rip), %rsi     # 0x374be
callq 0x40a0
leaq 0x34350(%rip), %rdi     # 0x4a5b0
leaq 0x21257(%rip), %rsi     # 0x374be
callq 0x40a0
movl $0x1, 0x34332(%rip)     # 0x4a5a8
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xdf80
movl $0x0, 0x34318(%rip)     # 0x4a5a8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: set_join_id
void
set_join_id(void)	// from first '(' til first ',' in OutBuf
{	char *s, *e;

	join_id = 0;
	s = strchr(OutBuf, '(');
	if (!s) { return; };
	e = strchr(s+1, ',');
	if (!e || e-s <= 1) { return; }

	join_id = (char *) e_malloc((e-s) * sizeof(char));
	strncpy(join_id, s+1, (e-s)-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, 0x3daed(%rip) # 0x54350
leaq 0x31ce6(%rip), %rdi     # 0x48550
movl $0x28, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16881
jmp 0x168f1
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x168af
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jg 0x168b1
jmp 0x168f1
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, 0x3da82(%rip)     # 0x54350
movq 0x3da7b(%rip), %rdi     # 0x54350
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: set_create_id
void
set_create_id(void)	// from the 1st '&(' to the 1st '),' in OutBuf
{	char *s, *e;

	join_id = 0;
	s = strchr(OutBuf, '&');
	if (!s) { return; }
	e = strchr(s+1, ')');
	if (!e || e-s <= 1) { return; }

	join_id = (char *) e_malloc((e-s) * sizeof(char));
	strncpy(join_id, s+2, (e-s)-1-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, 0x3da3d(%rip) # 0x54350
leaq 0x31c36(%rip), %rdi     # 0x48550
movl $0x26, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16931
jmp 0x169a5
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x29, %esi
callq 0x4110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1695f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jg 0x16961
jmp 0x169a5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, 0x3d9d2(%rip)     # 0x54350
movq 0x3d9cb(%rip), %rdi     # 0x54350
movq -0x8(%rbp), %rsi
addq $0x2, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
subq $0x1, %rdx
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: set_thread_id
void
set_thread_id(void)	// from the 2nd ',' to the third ',' in OutBuf
{	char *s, *e;

	thread_id = 0;
	s = strchr(OutBuf, ',');	// 1st
	if (!s) { return; }
	s = strchr(s+1, ',');		// 2nd
	if (!s) { return; }
	e = strchr(s+1, '>');		// Pmain->threadname
	if (!e)
	{	s = strchr(s+1, '.');	// now.threadname
		if (!s) { return; }
	} else
	{	s = e;
	}
	e = strchr(s+1, ',');		// 3rd
	if (!e || e-s <= 1) { return; }

	if (*(e-1) == ')') e--;		// &(Pmain->funcA),

	thread_id = (char *) e_malloc((e-s) * sizeof(char));
	strncpy(thread_id, s+1, (e-s)-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, 0x3d995(%rip) # 0x54358
leaq 0x31b86(%rip), %rdi     # 0x48550
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x169e4
jmp 0x16ad8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16a06
jmp 0x16ad8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x3e, %esi
callq 0x4110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16a47
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2e, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16a45
jmp 0x16ad8
jmp 0x16a4f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16a7d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jg 0x16a7f
jmp 0x16ad8
movq -0x10(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x29, %eax
jne 0x16a98
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, 0x3d8a3(%rip)     # 0x54358
movq 0x3d89c(%rip), %rdi     # 0x54358
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: set_thread_arg
void
set_thread_arg(void)	// from the 3rd ',' to the closing ')' in OutBuf
{	char *s, *e;

	thread_arg = 0;
	s = strchr(OutBuf, ',');	// 1st
	if (!s) { return; }
	s = strchr(s+1, ',');		// 2nd
	if (!s) { return; }
	s = strchr(s+1, ',');		// 3rd
	if (!s) { return; }
	e = strrchr(s+1, ')');
	if (!e) { return; }

	thread_arg = (char *) e_malloc(((e-s)+1) * sizeof(char));
	strncpy(thread_arg, s+1, (e-s)-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, 0x3d86d(%rip) # 0x54360
leaq 0x31a56(%rip), %rdi     # 0x48550
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16b14
jmp 0x16bb8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16b36
jmp 0x16bb8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x2c, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16b55
jmp 0x16bb8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x29, %esi
callq 0x4130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16b74
jmp 0x16bb8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, 0x3d7cb(%rip)     # 0x54360
movq 0x3d7c4(%rip), %rdi     # 0x54360
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: remember
void
remember(char *s, char *t)
{	Map *m;

	m = (Map *) e_malloc(sizeof(Map));
	m->from = s;
	m->to = t;
	m->nxt = mapped;
	mapped = m;
if (0)	fprintf(stderr, "remember: '%s' / '%s'\n", s, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x3d76c(%rip), %rcx     # 0x54368
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3d759(%rip)     # 0x54368
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: look_map
char *
look_map(char *s)
{	Map *m;

	for (m = mapped; m; m = m->nxt)
	{	if (strcmp(m->from, s) == 0)
		{	return m->to;
	}	}
	fprintf(stderr, "modex: error: failed to recognize pthread_create call: '%s'\n", s);
	return "_unknown_";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3d735(%rip), %rax     # 0x54368
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16c71
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x16c61
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16c98
jmp 0x16c63
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x16c37
movq 0x2e380(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1f6df(%rip), %rsi     # 0x36365
movb $0x0, %al
callq 0x4190
leaq 0x1f70e(%rip), %rax     # 0x363a2
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: alldone
void
alldone(void)
{
	if (fp)
	{
if (debug_io) fprintf(stderr, "close .. %p\n", fp);
		Fclose(fp);
fp = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x31004(%rip)     # 0x48540
je 0x17580
leaq 0x306a3(%rip), %rax     # 0x47be8
cmpl $0x0, (%rax)
je 0x17569
movq 0x2daa7(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
movq 0x30fe5(%rip), %rdx     # 0x48540
leaq 0x1ef4a(%rip), %rsi     # 0x364ac
movb $0x0, %al
callq 0x4190
movq 0x30fd0(%rip), %rdi     # 0x48540
callq 0x6d20
movq $0x0, 0x30fc0(%rip) # 0x48540
popq %rbp
retq
nopw %cs:(%rax,%rax)