LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: is_icall
int
is_icall(char *p)
{	Cname *s;

	for (s = icalls; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x32199(%rip), %r15     # 0x399e0
xorl %ebx, %ebx
testq %r15, %r15
je 0x7878
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0x786b
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x7851
jmp 0x7878
movl $0x1, 0x8(%r15)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: add_pname
void
add_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->nxt = pnames;
	pnames = s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3215a(%rip), %r14     # 0x399e8
testq %r14, %r14
je 0x78a8
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x78ed
movq 0x18(%r14), %r14
jmp 0x788e
movl $0x20, %edi
callq 0x6469
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x8(%r14)
movq 0x32106(%rip), %rax     # 0x399e8
movq %rax, 0x18(%r14)
movq %r14, 0x320fb(%rip)     # 0x399e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: is_pname
int
is_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x320e7(%rip), %r15     # 0x399e8
xorl %ebx, %ebx
testq %r15, %r15
je 0x7932
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0x7925
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x790b
jmp 0x7932
movl $0x1, 0x8(%r15)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: new_cmd
void
new_cmd(char c, char *s, int h)
{	Cmd *cmd;

	if (!s)
	{	fprintf(stderr, "modex: bad argument to '%c'\n", c);
		exit(1);
	}

	if (c == 'e')	// instrumented function
	{	add_icall(s);
	}
	if (c == 'p')	// passive proctype
	{	add_pname(s);
	}

	cmd = (Cmd *) e_malloc(sizeof(Cmd));
	memset(cmd, 0, sizeof(Cmd));
	cmd->cmd = c;
	cmd->n = nrprocs;
	cmd->arg = (char *) e_malloc(strlen(s)+1);
	strcpy(cmd->arg, s);

	if (Verbose_cmds)
	{	printf("New cmd <%c> <%s> <called from: %d> (nrprocs %d)\n", c, s, h, nrprocs);
	}

	if (cmds)
	{	cmds->nxt = cmd;
	}
	cmds = cmd;

	if (!ncmd)
	{	ncmd = cmds;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x80ae
movl %edx, %ebx
movq %rsi, %r14
movsbl %dil, %ebp
cmpl $0x70, %ebp
je 0x8008
cmpl $0x65, %ebp
jne 0x8010
movq %r14, %rdi
callq 0x77c6
jmp 0x8010
movq %r14, %rdi
callq 0x7880
movl $0x18, %edi
callq 0x6469
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl %ebp, (%rax)
movl 0x2f1bd(%rip), %eax     # 0x371f0
movl %eax, 0x4(%r15)
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
cmpl $0x0, 0x319af(%rip)     # 0x39a0c
je 0x807b
movl 0x2f18a(%rip), %r8d     # 0x371f0
leaq 0x1c12c(%rip), %rdi     # 0x24199
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x4140
movq 0x3198e(%rip), %rax     # 0x39a10
testq %rax, %rax
je 0x808b
movq %r15, 0x10(%rax)
movq %r15, 0x3197e(%rip)     # 0x39a10
cmpq $0x0, 0x3197e(%rip)     # 0x39a18
jne 0x80a3
movq %r15, 0x31975(%rip)     # 0x39a18
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %dil, %edi
callq 0x431b
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: expand_cmd
void
expand_cmd(char c, char *s, int h)	// e.g., s="one,two,three"
{	char *z = s;

	while (s != NULL && (z = strchr(s, ',')) != NULL)
	{	*z = '\0';
		new_cmd(c, s, h);
		s = z+1;
	}
	if (s != NULL)	// last one in list
	{	new_cmd(c, s, h);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x8124
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
movq %rsi, %rdi
movl $0x2c, %esi
callq 0x4130
movsbl %bpl, %ebp
testq %rax, %rax
je 0x810e
movq %rax, %r15
movb $0x0, (%r15)
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7fdb
movq %r15, %r14
incq %r14
movq %r14, %rdi
movl $0x2c, %esi
callq 0x4130
movq %rax, %r15
testq %rax, %rax
jne 0x80e3
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7fdb
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: mkfo
void
mkfo(char *fnm)
{
	if ((fo = fopen(fnm, MFLAGS)) == NULL)
	{	fprintf(stderr, "modex: checkprx: cannot create %s\n", fnm);
		exit(1);
	}
if (debug_io) fprintf(stderr, "Open %s -> %p\n", fnm, fo);

	add_fnm(fnm);
	/* printf("	%s\n", fnm); */
	nfls++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x21857(%rip), %rsi     # 0x2a8df
callq 0x4260
movq %rax, 0x30c2c(%rip)     # 0x39cc0
testq %rax, %rax
je 0x90d2
cmpl $0x0, 0x30968(%rip)     # 0x39a08
jne 0x90b2
movq %rbx, %rdi
callq 0xe728
incl 0x30c18(%rip)           # 0x39cc8
popq %rbx
retq
movq 0x2df3f(%rip), %rcx     # 0x36ff8
movq (%rcx), %rdi
leaq 0x1b226(%rip), %rsi     # 0x242e9
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0x90a2
movq %rbx, %rdi
callq 0x4343
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: header
void
header(char *bnm, char *suffix1)
{	char *fnm;

	if (fo)
	{	if (incode && !inltl) fprintf(fo, "}\n");
		if (fo != fdrv)
		{	if (debug_io)
			{	fprintf(stderr, "close 3 %p\n", fo);
			}
			Fclose(fo);
	}	}
	inlut = incode = inspn = indfn = ingui = inltl = 0;

	fnm = (char *) e_malloc(strlen(bnm)+strlen(suffix1)+1);
	strcpy(fnm, bnm);
	strcat(fnm, suffix1);

	if (strcmp(suffix1, ".drv") == 0)
	{	if (!hasdrv)
		{	mkfo(fnm);
			fdrv = fo;
			hasdrv = 1;
			/* include global header file by default */
			fprintf(fdrv, "#include \"_modex_.h\"\n");
		} else
			fo = fdrv;
	} else
	{	mkfo(fnm);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30bd4(%rip), %rcx     # 0x39cc0
testq %rcx, %rcx
je 0x9142
cmpb $0x1, 0x30bd4(%rip)     # 0x39ccc
jne 0x9119
testb $0x1, 0x30bcf(%rip)     # 0x39cd0
jne 0x9119
leaq 0x1db95(%rip), %rdi     # 0x26c9f
movl $0x2, %esi
movl $0x1, %edx
callq 0x42b0
movq 0x30ba0(%rip), %rdx     # 0x39cc0
cmpq 0x30bb1(%rip), %rdx     # 0x39cd8
je 0x9142
cmpl $0x0, 0x308d8(%rip)     # 0x39a08
jne 0x9214
movq 0x30b83(%rip), %rdi     # 0x39cc0
callq 0x793c
xorl %eax, %eax
movb %al, 0x30b86(%rip)      # 0x39cd0
movb %al, 0x30b90(%rip)      # 0x39ce0
movb %al, 0x30b8e(%rip)      # 0x39ce4
movb %al, 0x30b8c(%rip)      # 0x39ce8
movb %al, 0x30b6a(%rip)      # 0x39ccc
movb %al, 0x30b84(%rip)      # 0x39cec
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x6469
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4280
leaq 0x1b15e(%rip), %rsi     # 0x24304
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x91bf
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x907d
cmpb $0x0, 0x30b2a(%rip)     # 0x39cf0
je 0x91dc
movq 0x30b09(%rip), %rax     # 0x39cd8
movq %rax, 0x30aea(%rip)     # 0x39cc0
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x907d
movq 0x30ad5(%rip), %rcx     # 0x39cc0
movq %rcx, 0x30ae6(%rip)     # 0x39cd8
movb $0x1, 0x30af7(%rip)     # 0x39cf0
leaq 0x1b109(%rip), %rdi     # 0x24309
movl $0x15, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x42b0
movq 0x2dddd(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1b0d3(%rip), %rsi     # 0x242f8
xorl %eax, %eax
callq 0x41c0
jmp 0x9136
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: Arg_Add
void
Arg_Add(char *s, char *t)
{
	if (strlen(s) == 0) return;

	if (Verbose_cmds)
		printf("add arg %s %s\n", s, t);

	if (Argc >= 128)
	{	fprintf(stderr, "modex: too many arguments\n");
		exit(1);
	}
	Argv[Argc] = (char *) e_malloc(strlen(s)+strlen(t)+1);
	strcpy(Argv[Argc], s);
	strcat(Argv[Argc], t);

	if (Verbose_cmds)
		printf("	[%d] -> <%s>\n", Argc, Argv[Argc]);
	Argc++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x92dc
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x307bd(%rip)     # 0x39a0c
je 0x9265
leaq 0x1b0c7(%rip), %rdi     # 0x2431f
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4140
cmpl $0x80, 0x2df99(%rip)    # 0x37208
jge 0x92e8
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x6469
movslq 0x2df72(%rip), %r15     # 0x37208
leaq 0x30a63(%rip), %r12     # 0x39d00
movq %rax, (%r12,%r15,8)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq (%r12,%r15,8), %rdi
movq %rbx, %rsi
callq 0x4280
cmpl $0x0, 0x3074d(%rip)     # 0x39a0c
je 0x92d6
movq (%r12,%r15,8), %rdx
leaq 0x1b07d(%rip), %rdi     # 0x24349
movl %r15d, %esi
xorl %eax, %eax
callq 0x4140
incl 0x2df2c(%rip)           # 0x37208
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4367
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: Add_Args
void
Add_Args(char *s)
{	char *t, *v;

	if (Verbose_cmds)
		printf("add args <%s>\n", s);

	for (t = v = s; *t; t++)
		if (*t == ' ' || *t == '\t')
		{	*t = '\0';
			Arg_Add(v, "");
			v = t+1;
			while (*v == ' ' || *v == '\t')
				v++;
			t = v;
		}
	Arg_Add(v, "");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x30711(%rip)     # 0x39a0c
je 0x930e
leaq 0x1b054(%rip), %rdi     # 0x24358
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4140
leaq 0x1dd7f(%rip), %r14     # 0x27094
movq %rbx, %rdi
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0x932b
cmpl $0x20, %eax
je 0x932b
testl %eax, %eax
jne 0x9349
jmp 0x934e
movb $0x0, (%rbx)
movq %r14, %rsi
callq 0x9231
incq %rbx
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x9336
cmpl $0x9, %eax
je 0x9336
movq %rbx, %rdi
incq %rbx
jmp 0x9318
leaq 0x1dd3f(%rip), %rsi     # 0x27094
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9231
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: boiler_plate
void
boiler_plate(FILE *fd, int pre)
{
	fprintf(fd, "\t\tif [ -f _modex_.drv ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"error: no ./_modex_.drv file\"\n");
	fprintf(fd, "\t\t	exit 1\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\t%s model pan.? pan pan.exe _spin_nvr.tmp\n\n", RM);
	fprintf(fd, "\t\tif [ -f _modex_.h ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"\" > _modex_.h\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\techo \"// Generated by %s\" > model\n", VERSION);
	fprintf(fd, "\t\techo \"// `date` from %s\" >> model\n", file_name);
	fprintf(fd, "\t\techo \"\" >> model\n");
	fprintf(fd, "\t\tif [ -f _modex_.b4g ]\n");
	fprintf(fd, "\t\tthen	cat _modex_.b4g >> model\n");
	fprintf(fd, "\t\tfi\n");
	fprintf(fd, "\t\t%s _modex_.drv | grep -v -e '^$' -e '^# ' >> model", CPP);
	if (pre)
	{	fprintf(fd, " 2>&1");
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1b030(%rip), %rdi     # 0x243d2
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b030(%rip), %r14     # 0x243eb
movl $0xc, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b021(%rip), %rdi     # 0x243f8
movl $0x2b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b034(%rip), %rdi     # 0x24424
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b026(%rip), %r15     # 0x2442f
movl $0x6, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b011(%rip), %rsi     # 0x24436
leaq 0x1b037(%rip), %rdx     # 0x24463
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
leaq 0x1b02c(%rip), %rdi     # 0x24469
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
movl $0xc, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b015(%rip), %rdi     # 0x24480
movl $0x1b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
movl $0x6, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42b0
movq 0x2dce7(%rip), %rdx     # 0x37180
leaq 0x1affc(%rip), %rsi     # 0x2449c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movq 0x305c7(%rip), %rdx     # 0x39a78
leaq 0x1b009(%rip), %rsi     # 0x244c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
leaq 0x1b01d(%rip), %rdi     # 0x244e6
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b018(%rip), %rdi     # 0x244fa
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b018(%rip), %rdi     # 0x24513
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b020(%rip), %rdi     # 0x24534
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
leaq 0x1b00d(%rip), %rsi     # 0x2453a
leaq 0x1b03b(%rip), %rdx     # 0x2456f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
testl %ebp, %ebp
je 0x955b
leaq 0x1b032(%rip), %rdi     # 0x2457b
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42b0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4190
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: add_to_file
void
add_to_file(char *buf)
{	char *z;
	int i;

	if (fo && (inlut || incode || inspn || indfn))
	{	if (inspn && (z = strstr(buf, "\\#")) != NULL)
			*z = '\n';
		fprintf(fo, "%s\n", buf);
	} else if (ingui)
		for (i = 0; params[i].descr; i++)
		{	z = params[i].descr;
			if (!strncmp(buf, z, strlen(z)))
				*params[i].val = atoi(&buf[strlen(z)]);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2fe6f(%rip), %r14     # 0x39cc0
testq %r14, %r14
je 0x9e7b
movb 0x2fe8c(%rip), %al      # 0x39ce8
cmpb $0x0, 0x2fe89(%rip)     # 0x39cec
jne 0x9ee1
testb $0x1, 0x2fe60(%rip)     # 0x39ccc
jne 0x9ee1
testb $0x1, %al
jne 0x9ee1
testb $0x1, 0x2fe6b(%rip)     # 0x39ce4
jne 0x9ee1
movq 0x2d38e(%rip), %r14     # 0x37210
testq %r14, %r14
setne %al
andb 0x2fe52(%rip), %al      # 0x39ce0
cmpb $0x1, %al
jne 0x9ed5
leaq 0x2d387(%rip), %r12     # 0x37220
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40a0
testl %eax, %eax
jne 0x9ec8
addq %rbx, %r15
movq %r15, %rdi
callq 0x4270
movq -0x8(%r12), %rcx
movl %eax, (%rcx)
movq (%r12), %r14
addq $0x10, %r12
testq %r14, %r14
jne 0x9e99
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %al
je 0x9efc
leaq 0x1a9ae(%rip), %rsi     # 0x2489a
movq %rbx, %rdi
callq 0x42c0
testq %rax, %rax
je 0x9efc
movb $0xa, (%rax)
leaq 0x1b479(%rip), %rsi     # 0x2537c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: close_file
void
close_file(void)
{
	if (incode && !inltl)  fprintf(fo, "}\n");
	if (fo && fo != fdrv)
	{
if (debug_io) fprintf(stderr, "close 5 %p\n", fo);
		Fclose(fo);
	}
	fo = NULL;
	inlut = incode = inspn = inltl = 0;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x2fda9(%rip)     # 0x39ccc
jne 0x9f4b
testb $0x1, 0x2fda4(%rip)     # 0x39cd0
jne 0x9f4b
movq 0x2fd8b(%rip), %rcx     # 0x39cc0
leaq 0x1cd63(%rip), %rdi     # 0x26c9f
movl $0x2, %esi
movl $0x1, %edx
callq 0x42b0
movq 0x2fd6e(%rip), %rdx     # 0x39cc0
testq %rdx, %rdx
je 0x9f75
cmpq 0x2fd7a(%rip), %rdx     # 0x39cd8
je 0x9f75
cmpl $0x0, 0x2faa1(%rip)     # 0x39a08
jne 0x9f9c
movq 0x2fd50(%rip), %rdi     # 0x39cc0
callq 0x793c
movq $0x0, 0x2fd40(%rip) # 0x39cc0
xorl %eax, %eax
movb %al, 0x2fd48(%rip)      # 0x39cd0
movb %al, 0x2fd5a(%rip)      # 0x39ce8
movb %al, 0x2fd38(%rip)      # 0x39ccc
movb %al, 0x2fd52(%rip)      # 0x39cec
popq %rax
retq
movq 0x2d055(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1a8f0(%rip), %rsi     # 0x2489d
xorl %eax, %eax
callq 0x41c0
jmp 0x9f69
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: check_param
void
check_param(char *cmd)		/* check for filename param */
{	FILE *fd;
	char buf[1024], *fnm;

	fnm = &cmd[2];
	while (*fnm == ' ' || *fnm == '\t')
		fnm++;

	if (!*fnm) return;	/* must be inline contents */

	if ((fd = fopen(fnm, "r")) == NULL)
	{	if (cmd[1] != 'L')
			fprintf(stderr, "modex: no such file %s\n", cmd);
		return;
	}
if (debug_io) fprintf(stderr, "Open %s -> %p\n", fnm, fd);

	while (fgets(buf, sizeof(buf), fd))
		add_to_file(buf);

if (debug_io) fprintf(stderr, "close 6 %p\n", fd);
	Fclose(fd);
	close_file();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %r15
leaq 0x2(%rdi), %r14
movzbl (%r14), %eax
cmpl $0x9, %eax
je 0x9fd7
cmpl $0x20, %eax
jne 0x9fdc
incq %r14
jmp 0x9fc9
testl %eax, %eax
je 0xa054
leaq 0x1bdb4(%rip), %rsi     # 0x25d9b
movq %r14, %rdi
callq 0x4260
testq %rax, %rax
je 0xa04d
movq %rax, %rbx
cmpl $0x0, 0x2fa0a(%rip)     # 0x39a08
jne 0xa061
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x41a0
testq %rax, %rax
je 0xa035
movq %rsp, %r14
movq %r14, %rdi
callq 0x9e3f
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x41a0
testq %rax, %rax
jne 0xa018
cmpl $0x0, 0x2f9cc(%rip)     # 0x39a08
jne 0xa084
movq %rbx, %rdi
callq 0x793c
callq 0x9f1b
jmp 0xa054
cmpb $0x4c, 0x1(%r15)
jne 0xa0a1
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x2cf90(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1a277(%rip), %rsi     # 0x242e9
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0xa000
movq 0x2cf6d(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1a82c(%rip), %rsi     # 0x248c1
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
jmp 0xa03e
movq 0x2cf50(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1a7f7(%rip), %rsi     # 0x248a9
movq %r15, %rdx
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/modex.c
// Function: add_sed
void
add_sed(char *z)
{	char *n;
	int ln = strlen(z);
	if (strcmp(sedproc_info, "cat") == 0)
	{	n = (char *) e_malloc(ln + 1);
		strcpy(n, z);
	} else
	{	ln += strlen(sedproc_info) + strlen(" | ");
		n = (char *) e_malloc(ln + 1);
		sprintf(n, "%s | %s", sedproc_info, z);
	}
	sedproc_info = n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4110
movq %rax, %r14
movq 0x2d0e9(%rip), %r15     # 0x371c8
leaq 0x19403(%rip), %rsi     # 0x234e9
movq %r15, %rdi
callq 0x41b0
testl %eax, %eax
je 0xa126
movq %r15, %rdi
callq 0x4110
leal (%r14,%rax), %edi
addl $0x4, %edi
callq 0x6469
movq %rax, %r14
movq 0x2d0b8(%rip), %rdx     # 0x371c8
leaq 0x1a7b6(%rip), %rsi     # 0x248cd
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4290
jmp 0xa13f
incl %r14d
movl %r14d, %edi
callq 0x6469
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, 0x2d082(%rip)     # 0x371c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: x_stmnt
char *
x_stmnt(treenode *n)	/* service routine for lts.c */
{	char *p;

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

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

	return OutBuf;
}

// Assembly:
testq %rdi, %rdi
je 0xad8a
movl 0x1c(%rdi), %eax
cmpl $0x23, %eax
je 0xad92
cmpl $0x4, %eax
jne 0xad9a
leaq 0x1a273(%rip), %rax     # 0x24ffc
retq
leaq 0x19d09(%rip), %rax     # 0x24a9a
retq
leaq 0x1a25b(%rip), %rax     # 0x24ff4
retq
pushq %rbp
pushq %r14
pushq %rbx
movq $0x0, 0x2f5b7(%rip) # 0x3a360
xorl %ebp, %ebp
movl %ebp, 0x2f5b7(%rip)     # 0x3a368
leaq 0x2ec10(%rip), %r14     # 0x399c8
movl $0x1, (%r14)
movb $0x0, 0x2f5aa(%rip)     # 0x3a370
leaq 0x2f5a3(%rip), %rbx     # 0x3a370
callq 0xadf7
movl %ebp, (%r14)
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0xade3
testl %eax, %eax
jne 0xade6
jmp 0xadeb
movb $0x27, (%rbx)
incq %rbx
jmp 0xadd5
leaq 0x2f57e(%rip), %rax     # 0x3a370
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: nx_stmnt
char *
nx_stmnt(treenode *n)
{
	if (!n
	||  n->hdr.type == TN_STEMNT
	||  n->hdr.type == TN_BLOCK)
	{	return "";
	}

	do_level = 0;

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

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

	return rm_decor(OutBuf);
}

// Assembly:
testq %rdi, %rdi
je 0xc23b
movl 0x1c(%rdi), %eax
cmpl $0x4, %eax
je 0xc23b
cmpl $0x23, %eax
jne 0xc243
leaq 0x1ae52(%rip), %rax     # 0x27094
retq
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
movl %ebp, 0x2e119(%rip)     # 0x3a368
leaq 0x2d772(%rip), %r14     # 0x399c8
movl $0x1, (%r14)
movb %bpl, 0x2e10c(%rip)     # 0x3a370
leaq 0x2e105(%rip), %rbx     # 0x3a370
callq 0xadf7
movl %ebp, (%r14)
movb %bpl, 0x2b108(%rip)     # 0x37382
movw $0x2d2d, 0x2b0fd(%rip)  # imm = 0x2D2D
movb %bpl, 0x2f0e6(%rip)     # 0x3b370
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc296
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: rm_decor
char *
rm_decor(char *R)	/* strip "P...->"  and "now." decorations */
{	char *z, *y, *r;
	char patt[2048];
	Decor *d;

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %rbx
leaq 0x18d79(%rip), %rsi     # 0x25029
leaq 0x2b0c9(%rip), %rdx     # 0x37380
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4290
movq 0x300a5(%rip), %rax     # 0x3c370
movq %rax, 0x300a6(%rip)     # 0x3c378
movq $0x0, 0x30093(%rip) # 0x3c370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
je 0xc31f
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x4110
movq %rax, %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0xc58b
addq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x42c0
movq %rax, %r14
testq %rax, %rax
jne 0xc2fe
leaq 0x18d0b(%rip), %rsi     # 0x25031
movq %rbx, %rdi
callq 0x42c0
testq %rax, %rax
je 0xc361
movq %rax, %r14
leaq 0x18cf4(%rip), %r15     # 0x25031
movq %r14, %rdi
movl $0x4, %esi
callq 0xc58b
addq $0x4, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x42c0
movq %rax, %r14
testq %rax, %rax
jne 0xc33d
movq 0x30008(%rip), %r12     # 0x3c370
testq %r12, %r12
je 0xc3b7
leaq 0x2effc(%rip), %r14     # 0x3b370
movq %r14, %r15
movq (%r12), %r13
movq %r13, %r14
subq %rbx, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4090
addq %r15, %r14
movswq 0x8(%r12), %rbx
addq %r13, %rbx
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xc374
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x2efb9(%rip), %rbx     # 0x3b370
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: handle_double
void
handle_double(FILE *lf, char *s)
{	char *t, *v;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18c15(%rip), %rsi     # 0x25004
movq %r14, %rdi
callq 0x42c0
testq %rax, %rax
je 0xc449
movq %rax, %r12
leaq 0x18c0e(%rip), %r15     # 0x25014
leaq 0x18bf7(%rip), %r13     # 0x25004
movb $0x0, (%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41c0
movb $0x5f, (%r12)
movq %r12, %r14
addq $0xf, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x42c0
movq %rax, %r12
testq %rax, %rax
jne 0xc40d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: handle_special
void
handle_special(FILE *lf, char *s, char *last)
{	char *t, *v;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movl $0x25, %esi
callq 0x4130
testq %rax, %rax
je 0xc48d
cmpb $0x25, 0x1(%rax)
jne 0xc512
leaq 0x18b85(%rip), %rsi     # 0x25019
movq %r15, %rdi
callq 0x42c0
testq %rax, %rax
je 0xc4ee
movq %rax, %r13
leaq 0x18b6b(%rip), %r12     # 0x25016
leaq 0x18b67(%rip), %rbp     # 0x25019
movb $0x0, (%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3d9
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x41c0
movb $0x5f, (%r13)
movq %r13, %r15
addq $0xf, %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x42c0
movq %rax, %r13
testq %rax, %rax
jne 0xc4b2
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3d9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: add_decor
void
add_decor(Decor *d)
{	Decor *f, *lf = (Decor *) 0;

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

// Assembly:
movq 0x2fe48(%rip), %rcx     # 0x3c370
testq %rcx, %rcx
je 0xc539
movq (%rdi), %rsi
cmpq (%rcx), %rsi
jae 0xc54f
xorl %eax, %eax
jmp 0xc566
xorl %edx, %edx
leaq 0x10(%rdx), %rcx
testq %rdx, %rdx
leaq 0x2fe27(%rip), %rax     # 0x3c370
cmovneq %rcx, %rax
jmp 0xc587
movq %rcx, %rdx
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0xc53b
movq %rdx, %rax
movq %rcx, %rdx
cmpq (%rcx), %rsi
jae 0xc552
testq %rax, %rax
je 0xc575
movq %rcx, 0x10(%rdi)
addq $0x10, %rax
jmp 0xc587
leaq 0x2fdf4(%rip), %rax     # 0x3c370
movq 0x2fded(%rip), %rcx     # 0x3c370
movq %rcx, 0x10(%rdi)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x2fddd(%rip), %rdi     # 0x3c378
testq %rdi, %rdi
je 0xc5ad
movq 0x10(%rdi), %rax
movq %rax, 0x2fdcd(%rip)     # 0x3c378
jmp 0xc5ba
movl $0x18, %edi
callq 0x6469
movq %rax, %rdi
movq %r14, (%rdi)
movw %bx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc521
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: add_fct
void
add_fct(char *s, char *t)	/* names of fcts used in expressions */
{	Fcts *f;

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2fcd7(%rip), %r15     # 0x3c388
testq %r15, %r15
je 0xc6e2
leaq 0x18979(%rip), %r14     # 0x25036
cmpl $0x0, 0x2c(%r15)
jne 0xc6d9
movq (%r15), %rdx
cmpb $0x28, (%rdx)
je 0xc6d9
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xc6bd
movq 0x2fca7(%rip), %r15     # 0x3c390
testq %r15, %r15
je 0xc715
leaq 0x1894e(%rip), %r14     # 0x25043
cmpl $0x0, 0x2c(%r15)
jne 0xc70c
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0xc6f5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: add_substitute
void
add_substitute(char *s, char *t)	/* substitute rules defined in lut */
{	Fcts *f;

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xc792
movq %r14, %rdi
callq 0xc799
movq %rax, %r14
movl 0x2fc3a(%rip), %eax     # 0x3c380
movl %eax, 0x2c(%r14)
testq %rbx, %rbx
je 0xc770
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
jmp 0xc778
movq $0x0, 0x8(%r14)
movq 0x2fc19(%rip), %rax     # 0x3c398
movq %rax, 0x38(%r14)
movq %r14, 0x2fc0e(%rip)     # 0x3c398
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4667
jmp 0xc78a
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: modex_fct_el
static Fcts *
modex_fct_el(char *s)
{	Fcts *f;

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

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

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

	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq 0x6469
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x2d274(%rip), %rax     # 0x39a58
cmpl $0x0, (%rax)
je 0xc7f2
movl $0x1, 0x28(%rbx)
jmp 0xc80c
leaq 0x2a99f(%rip), %rax     # 0x37198
movq (%rax), %rsi
leaq 0x2ab7d(%rip), %rdi     # 0x37380
callq 0x41b0
testl %eax, %eax
je 0xc7e9
cmpl $0x0, 0x2fb95(%rip)     # 0x3c3a8
jle 0xc81e
movl $0x1, 0x30(%rbx)
jmp 0xc849
cmpl $0x0, 0x2fb87(%rip)     # 0x3c3ac
jle 0xc830
movl $0x2, 0x30(%rbx)
jmp 0xc849
cmpl $0x0, 0x2fb79(%rip)     # 0x3c3b0
jle 0xc842
movl $0x3, 0x30(%rbx)
jmp 0xc849
movl $0x0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: add_hidden
void
add_hidden(char *s, char *t, int d, int ln)
{	Fcts *g;

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

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

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

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

	t = sep_decor(t, g);

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

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

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

// Assembly:
cmpb $0x0, (%rdi)
je 0xc948
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x2fb29(%rip), %r12     # 0x3c3a0
testq %r12, %r12
je 0xc8c2
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xc8bb
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xc940
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0xc8bb
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xc940
movq 0x38(%r12), %r12
jmp 0xc877
movq %r15, %rdi
callq 0xc799
movq %rax, %r15
movq (%rax), %rax
movq %rax, 0x10(%r15)
movl %r14d, 0x24(%r15)
movl %ebp, 0x34(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949
movq %rax, %rbx
movq %rax, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x2aa71(%rip), %rbx     # 0x37380
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2fa6b(%rip), %rax     # 0x3c3a0
movq %rax, 0x38(%r15)
movq %r15, 0x2fa60(%rip)     # 0x3c3a0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: sep_decor
static char *
sep_decor(char *t, Fcts *g)
{	static char prep[512];

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xc978
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xca0e
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x3aa42(%rip), %r14     # 0x473e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
je 0xc9d7
leaq 0x3aa1e(%rip), %rbx     # 0x473e0
movb $0x20, (%rax)
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xc9c2
leaq 0x3aa02(%rip), %rdi     # 0x473e0
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xc9f0
movb $0x0, (%rax)
callq 0x42d0
movq (%rax), %rax
leaq 0x3a9e0(%rip), %rbx     # 0x473df
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xc9ff
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: add_full_global
void
add_full_global(char *s, char *t, int derived, int ln)
{	Fcts *g;
	char *z;
	int cntr = 0;

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
cmpb $0x0, (%rdi)
je 0xcce7
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0xcce7
movq %rdi, %r14
movb $0x1, %r15b
movq 0x2f7c6(%rip), %rbp     # 0x3c3b8
testq %rbp, %rbp
je 0xcc52
movq (%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x42c0
testq %rax, %rax
je 0xcc4c
movq %rax, %r12
cmpq %rbx, %rax
jne 0xcc3c
movq %r13, %rdi
callq 0x4110
movzbl (%r12,%rax), %eax
leal -0x20(%rax), %ecx
cmpl $0x3d, %ecx
ja 0xcc38
movabsq $0x2800000000000001, %rdx # imm = 0x2800000000000001
btq %rcx, %rdx
jb 0xcc76
testl %eax, %eax
je 0xcc76
cmpb $0x2a, -0x2(%r12)
jne 0xcc4c
cmpb $0x20, -0x1(%r12)
je 0xcc76
movq 0x38(%rbp), %rbp
jmp 0xcbf2
testb $0x1, %r15b
je 0xcce7
movq %r14, %rdi
movq %rbx, %rsi
movl (%rsp), %edx
movl 0x4(%rsp), %ecx
callq 0xca19
xorl %r15d, %r15d
jmp 0xcbeb
movq 0x18(%rbp), %r15
testq %r15, %r15
je 0xcc8e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xcce7
leaq 0x2cdd7(%rip), %rax     # 0x39a6c
testb $0x2, (%rax)
je 0xccb1
leaq 0x1840d(%rip), %rdi     # 0x250ae
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x4140
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, 0x18(%rbp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq (%rbp), %rdi
movq 0x18(%rbp), %rbx
callq 0x4110
cmpb $0x5d, (%rbx,%rax)
jne 0xcce7
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: dump_decls
void
dump_decls(FILE *fd)
{	Fcts *g;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2e455(%rip), %rbp     # 0x3c3b8
testq %rbp, %rbp
je 0xdfbe
leaq 0x17205(%rip), %r14     # 0x25174
leaq 0x1711e(%rip), %r15     # 0x25094
leaq 0x171ff(%rip), %r12     # 0x2517c
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xdfb5
movq %r13, %rdi
movq %r15, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xdfb5
movq (%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41c0
movq 0x38(%rbp), %rbp
testq %rbp, %rbp
jne 0xdf7d
movq 0x2e3db(%rip), %r12     # 0x3c3a0
testq %r12, %r12
je 0xe029
leaq 0x171a3(%rip), %r14     # 0x25174
leaq 0x170bc(%rip), %r15     # 0x25094
leaq 0x171ab(%rip), %r13     # 0x2518a
movq 0x10(%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xe01f
movq %rbp, %rdi
movq %r15, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xe01f
movq (%r12), %r8
movq %rbx, %rdi
leaq 0x17187(%rip), %rsi     # 0x25199
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x41c0
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0xdfdf
movq 0x2e390(%rip), %rbp     # 0x3c3c0
testq %rbp, %rbp
je 0xe08f
leaq 0x17138(%rip), %r14     # 0x25174
leaq 0x17051(%rip), %r15     # 0x25094
leaq 0x17149(%rip), %r12     # 0x25193
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xe086
movq %r13, %rdi
movq %r15, %rsi
callq 0x42c0
testq %rax, %rax
jne 0xe086
movq (%rbp), %rcx
movq 0x8(%rbp), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41c0
movq 0x38(%rbp), %rbp
testq %rbp, %rbp
jne 0xe04a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: spintype
char *
spintype(char *s, char *t)
{	static struct {
		char *tp; char *mp;
	} StS[] = {
		{ "bit ",	"bit" },	/* trailing space */
		{ "bool ",	"bool" },
		{ "byte ", 	"byte" },
		{ "pid ", 	"pid" },
		{ "int ",	"int" },
		{ "short ",	"short" },
		{ "uchar ", 	"byte" },
		{ "chan ", 	"chan" },

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

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

	return (char *) 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x170ef(%rip), %rsi     # 0x251a3
callq 0x41b0
testl %eax, %eax
je 0xe0f3
xorl %r14d, %r14d
leaq 0x28299(%rip), %r12     # 0x36360
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq $0x100, %r13            # imm = 0x100
je 0xe1bd
movq 0x10(%rcx,%r12), %rsi
movq %r15, %rdi
callq 0x41b0
movq %r13, %rcx
testl %eax, %eax
jne 0xe0c9
addq %r13, %r12
jmp 0xe0fa
leaq 0x28266(%rip), %r12     # 0x36360
testq %rbx, %rbx
je 0xe1b8
movq 0x8(%r12), %rdi
leaq 0x170db(%rip), %rsi     # 0x251ea
callq 0x41b0
testl %eax, %eax
je 0xe1b8
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x4130
testq %rax, %rax
jne 0xe17a
leaq 0x170c0(%rip), %rsi     # 0x251f5
movq %rbx, %rdi
callq 0x42c0
testq %rax, %rax
jne 0xe17a
leaq 0x17bd8(%rip), %rsi     # 0x25d21
movq %rbx, %rdi
callq 0x42c0
testq %rax, %rax
jne 0xe17a
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x4130
testq %rax, %rax
jne 0xe17a
movq %rbx, %rdi
movl $0x7b, %esi
callq 0x4130
testq %rax, %rax
je 0xe17f
xorl %r14d, %r14d
jmp 0xe1bd
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x4130
testq %rax, %rax
je 0xe1b8
movq %rax, %r14
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x4150
cmpq %rax, %r14
jne 0xe17a
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x4130
testq %rax, %rax
jne 0xe17a
movq 0x8(%r12), %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: do_hidden
void
do_hidden(FILE *fd)
{	Fcts *g;

	if (suppress)
		return;

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

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

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

			if (!Warnings)
				continue;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2bad4(%rip), %rax     # 0x39cb0
cmpl $0x0, (%rax)
setne %al
movq 0x2e1b7(%rip), %r14     # 0x3c3a0
testq %r14, %r14
sete %cl
orb %al, %cl
je 0xe202
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x20323(%rip), %r15     # 0x2e52f
leaq 0x2b84d(%rip), %r12     # 0x39a60
leaq 0x2b83e(%rip), %r13     # 0x39a58
cmpl $0x0, 0x20(%r14)
je 0xe22c
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0xe21a
jmp 0xe1f3
movl $0x1, 0x20(%r14)
cmpl $0x0, 0x24(%r14)
je 0xe28a
cmpl $0x3, 0x30(%r14)
je 0xe221
cmpl $0x0, (%r12)
jne 0xe221
cmpl $0x0, (%r13)
je 0xe2c9
leaq 0x2b815(%rip), %rax     # 0x39a6c
testb $0x2, (%rax)
jne 0xe270
movq 0x8(%r14), %rdi
leaq 0x16f95(%rip), %rsi     # 0x251fc
callq 0x41b0
testl %eax, %eax
je 0xe221
leaq 0x2b7f9(%rip), %rax     # 0x39a70
cmpl $0x0, (%rax)
je 0xe221
leaq 0x30(%r14), %rsi
movq %r14, %rdi
callq 0x48f0
jmp 0xe221
movq 0x10(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
je 0xe221
movq 0x18(%r14), %rcx
testq %rcx, %rcx
jne 0xe2a9
movq (%r14), %rcx
movq %rbx, %rdi
leaq 0x16fb6(%rip), %rsi     # 0x25269
movq %rbp, %rdx
leaq 0x16ecd(%rip), %r8      # 0x2518a
xorl %eax, %eax
callq 0x41c0
jmp 0xe221
leaq 0x28ec8(%rip), %rax     # 0x37198
movq (%rax), %rdi
movq 0x8(%r14), %rsi
callq 0x41b0
testl %eax, %eax
jne 0xe221
jmp 0xe250
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: checkfull
char *
checkfull(char *r, char *s, int ln)
{	char *t = (char *) 0;
	char *nt, *z;

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xe31c
movq %rsi, %rdi
movl $0x3d, %esi
callq 0x4130
testq %rax, %rax
je 0xe31c
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0xe30a
cmpl $0x9, %eax
je 0xe30a
jmp 0xe31e
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xe38d
cmpb $0x0, (%rbx)
je 0xe392
movq %rbx, %rdi
callq 0x4110
leal 0x1(,%rax,2), %edi
callq 0x6469
movq %rax, %r14
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x4130
movq %r14, %rcx
testq %rax, %rax
je 0xe370
movq %r14, %rcx
incq %rcx
movb $0x7b, (%r14)
jmp 0xe370
movb $0x5c, (%rcx)
incq %rcx
movb (%rbx), %al
movb %al, (%rcx)
incq %rcx
incq %rbx
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0xe360
testl %eax, %eax
jne 0xe366
cmpb $0x7b, (%r14)
jne 0xe388
movb $0x7d, (%rcx)
incq %rcx
movb $0x0, (%rcx)
jmp 0xe395
xorl %r14d, %r14d
jmp 0xe395
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq