LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x10(%rbp)
leaq -0x830(%rbp), %rdi
leaq 0x28944(%rip), %rsi     # 0x35291
leaq 0x38a0c(%rip), %rdx     # 0x45360
movb $0x0, %al
callq 0x4260
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x3dbe6(%rip), %rax     # 0x4a550
movq %rax, 0x3dbe7(%rip)     # 0x4a558
movq $0x0, 0x3dbd4(%rip) # 0x4a550
movq -0x28(%rbp), %rdi
leaq -0x830(%rbp), %rsi
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc9e5
movq -0x18(%rbp), %rax
movq %rax, -0x848(%rbp)
leaq -0x830(%rbp), %rdi
callq 0x40f0
movq -0x848(%rbp), %rdi
movl %eax, %esi
callq 0xcd30
movq -0x18(%rbp), %rax
movq %rax, -0x840(%rbp)
leaq -0x830(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x840(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xc97c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x288a1(%rip), %rsi     # 0x35299
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xca23
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0xcd30
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0xc9ed
cmpq $0x0, 0x3db25(%rip)     # 0x4a550
jne 0xca3a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcae3
leaq 0x3cb0f(%rip), %rax     # 0x49550
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x3dafc(%rip), %rax     # 0x4a550
movq %rax, -0x838(%rbp)
cmpq $0x0, -0x838(%rbp)
je 0xcacb
movq -0x838(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x4080
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq -0x838(%rbp), %rcx
movswl 0x8(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x838(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x838(%rbp)
jmp 0xca5b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x40a0
leaq 0x3ca71(%rip), %rax     # 0x49550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x28719(%rip), %rsi     # 0x3526c
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xcb9d
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcaf0
movq -0x8(%rbp), %rdi
leaq 0x286fb(%rip), %rsi     # 0x3527c
movb $0x0, %al
callq 0x4190
movq -0x18(%rbp), %rax
movb $0x5f, (%rax)
movq -0x18(%rbp), %rax
addq $0xf, %rax
movq %rax, -0x20(%rbp)
jmp 0xcb48
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcaf0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x286b0(%rip), %rsi     # 0x3527f
callq 0x4280
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xcbf2
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x25, %eax
je 0xcbf0
jmp 0xcc72
jmp 0xcbf2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2867c(%rip), %rsi     # 0x35281
callq 0x4280
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xcc4f
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xcb30
movq -0x8(%rbp), %rdi
leaq 0x2864b(%rip), %rsi     # 0x3527e
movb $0x0, %al
callq 0x4190
movq -0x20(%rbp), %rax
movb $0x5f, (%rax)
movq -0x20(%rbp), %rax
addq $0xf, %rax
movq %rax, -0x28(%rbp)
jmp 0xcbfa
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xcb30
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x28b56(%rip), %rsi     # 0x357c1
movb $0x0, %al
callq 0x4190
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x3d8b9(%rip), %rax     # 0x4a550
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcd07
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xccef
cmpq $0x0, -0x18(%rbp)
je 0xccd3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xcced
movq 0x3d876(%rip), %rcx     # 0x4a550
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x3d863(%rip)     # 0x4a550
jmp 0xcd27
jmp 0xccf1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcc9b
cmpq $0x0, -0x18(%rbp)
je 0xcd1c
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xcd27
movq -0x8(%rbp), %rax
movq %rax, 0x3d829(%rip)     # 0x4a550
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x3d811(%rip)     # 0x4a558
je 0xcd65
movq 0x3d808(%rip), %rax     # 0x4a558
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x3d7f5(%rip)     # 0x4a558
jmp 0xcd73
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0xcc80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movl 0x3d75e(%rip), %ecx     # 0x4a560
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
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)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
movq 0x3d728(%rip), %rcx     # 0x4a568
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3d715(%rip)     # 0x4a568
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movl 0x3d6b2(%rip), %ecx     # 0x4a560
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq 0x3d6b4(%rip), %rcx     # 0x4a570
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x3d6a1(%rip)     # 0x4a570
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: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3d675(%rip), %rax     # 0x4a568
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcf42
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0xcf32
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0xcf30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x28375(%rip), %rsi     # 0x3529e
movb $0x0, %al
callq 0x4190
jmp 0xcf32
jmp 0xcf34
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcef7
movq 0x3d627(%rip), %rax     # 0x4a570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcf87
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0xcf77
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2833b(%rip), %rsi     # 0x352ab
movb $0x0, %al
callq 0x4190
jmp 0xcf79
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcf4d
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4280
cmpq $0x0, %rax
je 0xcfd7
movq 0x3803e(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x381ac(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq 0x282e9(%rip), %rsi     # 0x352b7
movb $0x0, %al
callq 0x4190
jmp 0xd050
movq -0x8(%rbp), %rdi
callq 0xd060
movq %rax, -0x18(%rbp)
movl 0x3d576(%rip), %ecx     # 0x4a560
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xd02a
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)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
jmp 0xd036
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x3d53b(%rip), %rcx     # 0x4a578
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3d528(%rip)     # 0x4a578
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_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4160
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
leaq 0x3ab79(%rip), %rax     # 0x47c38
cmpl $0x0, (%rax)
jne 0xd0df
leaq 0x380ad(%rip), %rax     # 0x45178
movq (%rax), %rsi
leaq 0x3828b(%rip), %rdi     # 0x45360
callq 0x4180
cmpl $0x0, %eax
jne 0xd0ea
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
cmpl $0x0, 0x3d49b(%rip)     # 0x4a58c
jle 0xd100
movq -0x10(%rbp), %rax
movl $0x1, 0x30(%rax)
jmp 0xd13b
cmpl $0x0, 0x3d489(%rip)     # 0x4a590
jle 0xd116
movq -0x10(%rbp), %rax
movl $0x2, 0x30(%rax)
jmp 0xd139
cmpl $0x0, 0x3d477(%rip)     # 0x4a594
jle 0xd12c
movq -0x10(%rbp), %rax
movl $0x3, 0x30(%rax)
jmp 0xd137
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
jmp 0xd139
jmp 0xd13b
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x4110
cmpq $0x0, %rax
jne 0xd36c
movq -0x8(%rbp), %rdi
movl $0x5b, %esi
callq 0x4110
cmpq $0x0, %rax
je 0xd42d
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x8(%rbp), %rsi
leaq 0x48219(%rip), %rdi     # 0x555c0
callq 0x40a0
leaq 0x4820d(%rip), %rdi     # 0x555c0
movl $0x2a, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xd3d0
movq -0x8(%rbp), %rax
movb $0x20, (%rax)
jmp 0xd3ac
leaq 0x481e9(%rip), %rdi     # 0x555c0
movl $0x5b, %esi
callq 0x4110
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xd3f2
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq 0x481c7(%rip), %rax     # 0x555c0
movq %rax, -0x8(%rbp)
callq 0x4290
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xd42b
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xd3fd
jmp 0xd42d
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3acd5(%rip), %rax     # 0x4a598
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf933
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x25b84(%rip), %rsi     # 0x35461
callq 0x4280
cmpq $0x0, %rax
jne 0xf923
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x25a5e(%rip), %rsi     # 0x35355
callq 0x4280
cmpq $0x0, %rax
jne 0xf923
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x25b4d(%rip), %rsi     # 0x35469
movb $0x0, %al
callq 0x4190
jmp 0xf925
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf8c7
movq 0x3ac46(%rip), %rax     # 0x4a580
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf9b1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x25b0d(%rip), %rsi     # 0x35461
callq 0x4280
cmpq $0x0, %rax
jne 0xf9a1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x259e7(%rip), %rsi     # 0x35355
callq 0x4280
cmpq $0x0, %rax
jne 0xf9a1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %r8
leaq 0x25af3(%rip), %rsi     # 0x35486
leaq 0x25add(%rip), %rdx     # 0x35477
movb $0x0, %al
callq 0x4190
jmp 0xf9a3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf93e
movq 0x3abe8(%rip), %rax     # 0x4a5a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfa30
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x25a8f(%rip), %rsi     # 0x35461
callq 0x4280
cmpq $0x0, %rax
jne 0xfa20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x25969(%rip), %rsi     # 0x35355
callq 0x4280
cmpq $0x0, %rax
jne 0xfa20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x25a67(%rip), %rsi     # 0x35480
movb $0x0, %al
callq 0x4190
jmp 0xfa22
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf9bc
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: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x35cfe(%rip), %rax     # 0x45760
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xfbca
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x35cde(%rip), %rax     # 0x45760
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0xfbba
cmpq $0x0, -0x18(%rbp)
je 0xfb9c
movslq -0x1c(%rbp), %rcx
leaq 0x35cb0(%rip), %rax     # 0x45760
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq 0x25a15(%rip), %rsi     # 0x354d7
callq 0x4180
cmpl $0x0, %eax
je 0xfb9c
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
callq 0x4110
cmpq $0x0, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
leaq 0x259ef(%rip), %rsi     # 0x354e2
callq 0x4280
cmpq $0x0, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
leaq 0x2651c(%rip), %rsi     # 0x36029
callq 0x4280
cmpq $0x0, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x4110
cmpq $0x0, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
movl $0x7b, %esi
callq 0x4110
cmpq $0x0, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
movl $0x5b, %esi
callq 0x4110
cmpq $0x0, %rax
je 0xfb9c
movq -0x18(%rbp), %rdi
movl $0x5b, %esi
callq 0x4110
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x5b, %esi
callq 0x4130
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0xfbb8
movq -0x18(%rbp), %rdi
movl $0x3d, %esi
callq 0x4110
cmpq $0x0, %rax
jne 0xfbb8
movslq -0x1c(%rbp), %rcx
leaq 0x35bb9(%rip), %rax     # 0x45760
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xfbd2
jmp 0xfbca
jmp 0xfbbc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfa57
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xff1e
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x4110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xff1e
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x31(%rbp)
je 0xff05
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xff0e
jmp 0xff1c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xfee4
jmp 0xff1e
cmpq $0x0, -0x20(%rbp)
je 0xfff9
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xfff9
movq -0x20(%rbp), %rdi
callq 0x40f0
shlq %rax
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2c, %esi
callq 0x4110
cmpq $0x0, %rax
je 0xff7e
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x7b, (%rax)
jmp 0xff80
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xffcc
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0xffa7
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x5c, (%rax)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xff80
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0xffea
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x7d, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
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: cleanse
void
cleanse(char *p)
{	char *z;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x25a30(%rip), %rsi     # 0x35a57
callq 0x4280
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1003f
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
jmp 0x1001c
jmp 0x10041
movq -0x8(%rbp), %rdi
leaq 0x23188(%rip), %rsi     # 0x331d4
callq 0x4280
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x10076
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
jmp 0x10041
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq 0x3d826(%rip), %rax     # 0x4dc70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x104ee
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
je 0x10488
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x245f5(%rip), %rsi     # 0x34a73
callq 0x4180
cmpl $0x0, %eax
jne 0x104db
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
je 0x104b5
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x245c8(%rip), %rsi     # 0x34a73
callq 0x4180
cmpl $0x0, %eax
jne 0x104db
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x104d2
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x104f5
movl $0x1, -0x4(%rbp)
jmp 0x104f5
jmp 0x104dd
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1044e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq 0x3c269(%rip), %rcx     # 0x4c7b8
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x3c256(%rip)     # 0x4c7b8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3704d(%rip), %rax     # 0x47ba0
cmpl $0x0, (%rax)
je 0x10bcb
cmpq $0x0, 0x379e0(%rip)     # 0x48540
je 0x10bcb
cmpq $0x0, -0x8(%rbp)
je 0x10bcb
leaq 0x372fc(%rip), %rax     # 0x47e6c
cmpl $0x0, (%rax)
jne 0x10bcb
leaq 0x370c4(%rip), %rax     # 0x47c40
cmpl $0x0, (%rax)
jne 0x10bcb
leaq 0x372f4(%rip), %rax     # 0x47e7c
cmpl $0x0, (%rax)
jne 0x10bcb
movq 0x379ac(%rip), %rdi     # 0x48540
movq -0x8(%rbp), %rsi
leaq 0x2691f(%rip), %rdx     # 0x374be
callq 0xcbb0
movq -0x8(%rbp), %rdi
leaq 0x252eb(%rip), %rsi     # 0x35e9a
callq 0x4280
cmpq $0x0, %rax
je 0x10bc9
movl 0x437b4(%rip), %eax     # 0x54374
addl $0x1, %eax
movl %eax, 0x437ab(%rip)     # 0x54374
jmp 0x10bcb
movb $0x0, 0x3bbfe(%rip)     # 0x4c7d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: do_externals
void
do_externals(FILE *fd)
{	Spress *s;

	for (s = externals; s; s = s->nxt)
	{	if (s->purged)
		{	continue;
		}
		s->purged = 1;
		fprintf(fd, "c_track \"%s\" \"%s\"\n",
			s->vn, s->pn);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3d085(%rip), %rax     # 0x4dc78
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10c44
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x10c0a
jmp 0x10c36
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x25cf9(%rip), %rsi     # 0x36928
movb $0x0, %al
callq 0x4190
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10bf7
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10cf9
movq -0x8(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jle 0x10cf9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10cf7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10ce7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x23faa(%rip), %rsi     # 0x34c54
callq 0x4180
cmpl $0x0, %eax
je 0x10ce7
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x10ce7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x10ce7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x18050
jmp 0x10cf7
jmp 0x10ce9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x10c89
jmp 0x10cf9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x10d34
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10c50
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10d00
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x44849(%rip)     # 0x555a0
jne 0x10d5b
jmp 0x10da2
movq -0x8(%rbp), %rdi
callq 0x17d60
movq 0x4483d(%rip), %rax     # 0x555a8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10da2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x17ef0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17c90
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10d6f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3b7e5(%rip), %rax     # 0x4c7b8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11020
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x24892(%rip), %rsi     # 0x3587e
callq 0x4280
cmpq $0x0, %rax
je 0x11010
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2487a(%rip), %rsi     # 0x35883
movb $0x0, %al
callq 0x4190
jmp 0x11012
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10fd7
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: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq 0x3c7d1(%rip), %rcx     # 0x4d850
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x3c7be(%rip)     # 0x4d850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x3c506(%rip), %rax     # 0x4dc70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x117b5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x117a5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x117a5
jmp 0x11889
jmp 0x117a7
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1176e
movl $0x28, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq 0x3c433(%rip), %rcx     # 0x4dc70
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x3c420(%rip)     # 0x4dc70
movq -0x8(%rbp), %rdi
leaq 0x23218(%rip), %rsi     # 0x34a73
callq 0x4180
cmpl $0x0, %eax
jne 0x11889
movq -0x10(%rbp), %rdi
leaq 0x23203(%rip), %rsi     # 0x34a73
callq 0x4180
cmpl $0x0, %eax
jne 0x11889
movl 0x3c3e4(%rip), %eax     # 0x4dc64
addl $0x1, %eax
movl %eax, 0x3c3db(%rip)     # 0x4dc64
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x38355(%rip), %rax     # 0x4a578
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12291
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x1223a
jmp 0x12283
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12268
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x238d4(%rip), %rsi     # 0x35b33
movb $0x0, %al
callq 0x4190
jmp 0x12281
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x238cb(%rip), %rsi     # 0x35b45
movb $0x0, %al
callq 0x4190
jmp 0x12283
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12227
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
cmpl $0x0, 0x382c9(%rip)     # 0x4a590
je 0x1237b
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x122ef
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x122d5
movq -0x18(%rbp), %rdi
leaq 0x2304f(%rip), %rsi     # 0x35349
movl $0x4, %edx
callq 0x4090
cmpl $0x0, %eax
jne 0x12379
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1029(%rbp)
je 0x1233c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
sete %al
movb %al, -0x1029(%rbp)
movb -0x1029(%rbp), %al
testb $0x1, %al
jne 0x12348
jmp 0x12356
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12315
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x12377
movq -0x8(%rbp), %rdi
leaq 0x25151(%rip), %rsi     # 0x374be
callq 0x40a0
jmp 0x12462
jmp 0x12379
jmp 0x1237b
movq 0x381f6(%rip), %rax     # 0x4a578
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x12462
jmp 0x12399
movq -0x8(%rbp), %rdi
movq -0x1028(%rbp), %rax
movq (%rax), %rsi
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x12449
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x1028(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x123f6
leaq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4250
leaq -0x1020(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1040(%rbp)
movq -0x1028(%rbp), %rax
movq (%rax), %rdi
callq 0x40f0
movq -0x1040(%rbp), %rsi
movq -0x1038(%rbp), %rdi
addq %rax, %rsi
callq 0x4250
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x40a0
jmp 0x12399
jmp 0x1244b
movq -0x1028(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x1028(%rbp)
jmp 0x12389
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3b7f1(%rip), %rax     # 0x4dc78
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x124d2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x124c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x124c2
jmp 0x12563
jmp 0x124c4
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1248b
movl $0x28, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq 0x3b728(%rip), %rcx     # 0x4dc78
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3b715(%rip)     # 0x4dc78
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x12599
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x125a2
jmp 0x125b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x12578
jmp 0x125b2
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xa(%rbp)
je 0x125d3
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x125dc
jmp 0x125f0
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
jmp 0x125b2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: add_constants
void
add_constants(char *p)
{	char *q;

	q = nextarg(p);
	if (*q != '\0')
		add_constants(q);
	add_constant(p, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12570
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1262e
movq -0x10(%rbp), %rdi
callq 0x12600
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6810
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: notimported
void
notimported(FILE *fd)
{	Spress *s;

	for (s = spress; s; s = s->nxt)
		if (!s->hit
		&&  !strstr(s->pn, "Global"))	/* covers unused global declarations */
			fprintf(fd, "Redundant: Import %s %s\n", s->vn, s->pn); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3b60d(%rip), %rax     # 0x4dc70
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x126c3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x126b3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x20a26(%rip), %rsi     # 0x330ad
callq 0x4280
cmpq $0x0, %rax
jne 0x126b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x234a8(%rip), %rsi     # 0x35b54
movb $0x0, %al
callq 0x4190
jmp 0x126b5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12667
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: read_more
void
read_more(FILE *fd, char *buf)
{	char *p, more[1024];


	while (fgets(more, 1024, fd))
	{	buf[strlen(buf)-1] = '\0';
		p = &more[strlen(more)-1];

		while (*p == '\n'
		||     *p == '\r'
		||     *p == '\t'
		||     *p == ' ')
			*p-- = '\0';

		p = &more[0];
		while (*p == ' ' || *p == '\t')
			p++;

		strcat(buf, " ");
		strcat(buf, p);
		if (buf[strlen(buf)-1] != '\\')
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x4170
cmpq $0x0, %rax
je 0x12853
movq -0x10(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x428(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
leaq -0x420(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
subq $0x1, %rcx
leaq -0x420(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x429(%rbp)
je 0x12798
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x429(%rbp)
je 0x12798
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x429(%rbp)
je 0x12798
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x429(%rbp)
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x127a4
jmp 0x127b8
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
jmp 0x12749
leaq -0x420(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x42a(%rbp)
je 0x127ea
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x42a(%rbp)
movb -0x42a(%rbp), %al
testb $0x1, %al
jne 0x127f6
jmp 0x12804
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x127c3
movq -0x10(%rbp), %rdi
leaq 0x23851(%rip), %rsi     # 0x36060
callq 0x4250
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4250
movq -0x10(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x438(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x1284e
jmp 0x12853
jmp 0x126e3
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/xtract.c
// Function: add_comment
static void
add_comment(int nr, char *s)
{	Cache *d;

	if (strncmp(s, Banner, strlen(Banner)) == 0)
		return;

	d = (Cache *) e_malloc(sizeof(Cache));
	d->level = Down;
	d->s = (char *) e_malloc(strlen(s)+1);
	strcpy(d->s, s);
	d->hit = nr-1;	/* -1 correction */
	d->printed = 0;
	d->nxt = (Cache *) 0;
	if (!commstail)
		comms = commstail = d;
	else
	{	commstail->nxt = d;
		commstail = d;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2167c(%rip), %rsi     # 0x34ac6
movl $0x14, %edx
callq 0x4090
cmpl $0x0, %eax
jne 0x1345e
jmp 0x13503
movl $0x28, %edi
callq 0x4a70
movq %rax, -0x18(%rbp)
movl 0x370ee(%rip), %ecx     # 0x4a560
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40a0
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
cmpq $0x0, 0x40ec5(%rip)     # 0x54398
jne 0x134e9
movq -0x18(%rbp), %rax
movq %rax, 0x40eb8(%rip)     # 0x54398
movq %rax, 0x3a7a9(%rip)     # 0x4dc90
jmp 0x13503
movq -0x18(%rbp), %rcx
movq 0x40ea4(%rip), %rax     # 0x54398
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x40e95(%rip)     # 0x54398
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)