LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2082b(%rip), %rsi     # 0x277ef
callq 0x4270
movq %rax, 0x2fd00(%rip)     # 0x36cd0
testq %rax, %rax
je 0x700e
cmpl $0x0, 0x2fa3c(%rip)     # 0x36a18
jne 0x6fee
movq %rbx, %rdi
callq 0xcb92
incl 0x2fcec(%rip)           # 0x36cd8
popq %rbx
retq
movq 0x2d003(%rip), %rcx     # 0x33ff8
movq (%rcx), %rdi
leaq 0x1a2ea(%rip), %rsi     # 0x212e9
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0x6fde
movq 0x2cfe3(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1a2a7(%rip), %rsi     # 0x212c6
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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 0x2fc8d(%rip), %rcx     # 0x36cd0
testq %rcx, %rcx
je 0x7091
cmpb $0x1, 0x2fc8d(%rip)     # 0x36cdc
jne 0x7073
testb $0x1, 0x2fc88(%rip)     # 0x36ce0
jne 0x7073
leaq 0x1cb3e(%rip), %rdi     # 0x23b9f
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
movq 0x2fc5d(%rip), %rcx     # 0x36cd0
cmpq 0x2fc6e(%rip), %rcx     # 0x36ce8
je 0x7091
cmpl $0x0, 0x2f995(%rip)     # 0x36a18
jne 0x715f
movq %rcx, %rdi
callq 0x59e0
xorl %eax, %eax
movb %al, 0x2fc47(%rip)      # 0x36ce0
movb %al, 0x2fc51(%rip)      # 0x36cf0
movb %al, 0x2fc4f(%rip)      # 0x36cf4
movb %al, 0x2fc4d(%rip)      # 0x36cf8
movb %al, 0x2fc2b(%rip)      # 0x36cdc
movb %al, 0x2fc45(%rip)      # 0x36cfc
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x4739
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4290
leaq 0x1a20f(%rip), %rsi     # 0x21304
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x710e
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6fb9
cmpb $0x0, 0x2fbeb(%rip)     # 0x36d00
je 0x712b
movq 0x2fbca(%rip), %rax     # 0x36ce8
movq %rax, 0x2fbab(%rip)     # 0x36cd0
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x6fb9
movq 0x2fb96(%rip), %rcx     # 0x36cd0
movq %rcx, 0x2fba7(%rip)     # 0x36ce8
movb $0x1, 0x2fbb8(%rip)     # 0x36d00
leaq 0x1a1ba(%rip), %rdi     # 0x21309
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x42c0
movq 0x2ce92(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1a188(%rip), %rsi     # 0x212f8
movq %rcx, %rdx
xorl %eax, %eax
callq 0x41c0
movq 0x2fb4f(%rip), %rcx     # 0x36cd0
jmp 0x7089
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, (%rdi)
je 0x723b
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2f878(%rip)     # 0x36a1c
je 0x71ba
leaq 0x1a172(%rip), %rdi     # 0x2131f
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4140
cmpl $0x80, 0x2d054(%rip)    # 0x34218
jge 0x7244
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x4739
movl 0x2d02e(%rip), %ebp     # 0x34218
movslq %ebp, %r15
leaq 0x2fb1c(%rip), %r12     # 0x36d10
movq %rax, (%r12,%r15,8)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq (%r12,%r15,8), %rdi
movq %rbx, %rsi
callq 0x4290
cmpl $0x0, 0x2f806(%rip)     # 0x36a1c
je 0x7233
movq (%r12,%r15,8), %rdx
leaq 0x1a126(%rip), %rdi     # 0x21349
movl %r15d, %esi
xorl %eax, %eax
callq 0x4140
movl 0x2cfe5(%rip), %ebp     # 0x34218
incl %ebp
movl %ebp, 0x2cfdd(%rip)     # 0x34218
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2cdad(%rip), %rax     # 0x33ff8
movq (%rax), %rcx
leaq 0x1a0d9(%rip), %rdi     # 0x2132e
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/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, 0x2f7a6(%rip)     # 0x36a1c
je 0x7289
leaq 0x1a0d9(%rip), %rdi     # 0x21358
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4140
leaq 0x1cd01(%rip), %r14     # 0x23f91
movq %rbx, %rdi
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0x72a6
cmpl $0x20, %eax
je 0x72a6
testl %eax, %eax
jne 0x72c4
jmp 0x72c9
movb $0x0, (%rbx)
movq %r14, %rsi
callq 0x7186
incq %rbx
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x72b1
cmpl $0x9, %eax
je 0x72b1
movq %rbx, %rdi
incq %rbx
jmp 0x7293
leaq 0x1ccc1(%rip), %rsi     # 0x23f91
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7186
// File: /workspace/github_c_makefile_star2_O2/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 0x2ef12(%rip), %r14     # 0x36cd0
testq %r14, %r14
je 0x7de8
movb 0x2ef2f(%rip), %al      # 0x36cf8
cmpb $0x0, 0x2ef2c(%rip)     # 0x36cfc
jne 0x7e42
testb $0x1, 0x2ef03(%rip)     # 0x36cdc
jne 0x7e42
testb $0x1, %al
jne 0x7e42
testb $0x1, 0x2ef0e(%rip)     # 0x36cf4
jne 0x7e42
cmpb $0x1, 0x2ef01(%rip)     # 0x36cf0
jne 0x7e36
leaq 0x2c430(%rip), %r12     # 0x34228
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x7e36
movq %r15, %rdi
callq 0x4110
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40a0
testl %eax, %eax
jne 0x7e30
addq %rbx, %r14
movq %r14, %rdi
callq 0x4280
movq (%r12), %rcx
movl %eax, (%rcx)
addq $0x10, %r12
jmp 0x7df8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %al
je 0x7e5d
leaq 0x19a4d(%rip), %rsi     # 0x2189a
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0x7e5d
movb $0xa, (%rax)
leaq 0x1a418(%rip), %rsi     # 0x2227c
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_O2/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, 0x2ee58(%rip)     # 0x36cdc
jne 0x7ea8
testb $0x1, 0x2ee53(%rip)     # 0x36ce0
jne 0x7ea8
movq 0x2ee3a(%rip), %rcx     # 0x36cd0
leaq 0x1bd02(%rip), %rdi     # 0x23b9f
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
movq 0x2ee21(%rip), %rdx     # 0x36cd0
testq %rdx, %rdx
je 0x7ece
cmpq 0x2ee2d(%rip), %rdx     # 0x36ce8
je 0x7ece
cmpl $0x0, 0x2eb54(%rip)     # 0x36a18
jne 0x7ef2
movq %rdx, %rdi
callq 0x59e0
andq $0x0, 0x2edfa(%rip)     # 0x36cd0
xorl %eax, %eax
movb %al, 0x2ee02(%rip)      # 0x36ce0
movb %al, 0x2ee14(%rip)      # 0x36cf8
movb %al, 0x2edf2(%rip)      # 0x36cdc
movb %al, 0x2ee0c(%rip)      # 0x36cfc
popq %rax
retq
movq 0x2c0ff(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1999a(%rip), %rsi     # 0x2189d
xorl %eax, %eax
callq 0x41c0
movq 0x2edbf(%rip), %rdx     # 0x36cd0
jmp 0x7ec6
// File: /workspace/github_c_makefile_star2_O2/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 0x7f34
cmpl $0x20, %eax
jne 0x7f39
incq %r14
jmp 0x7f26
testl %eax, %eax
je 0x7f9e
leaq 0x1ad57(%rip), %rsi     # 0x22c9b
movq %r14, %rdi
callq 0x4270
testq %rax, %rax
je 0x7f97
movq %rax, %rbx
cmpl $0x0, 0x2eabd(%rip)     # 0x36a18
jne 0x7fab
movq %rsp, %r14
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x4190
testq %rax, %rax
je 0x7f7f
movq %r14, %rdi
callq 0x7dac
jmp 0x7f60
cmpl $0x0, 0x2ea92(%rip)     # 0x36a18
jne 0x7fcb
movq %rbx, %rdi
callq 0x59e0
callq 0x7e7c
jmp 0x7f9e
cmpb $0x4c, 0x1(%r15)
jne 0x7fe8
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x2c046(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1932d(%rip), %rsi     # 0x212e9
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0x7f5d
movq 0x2c026(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x198e5(%rip), %rsi     # 0x218c1
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
jmp 0x7f88
movq 0x2c009(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x198b0(%rip), %rsi     # 0x218a9
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_O2/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 0x2c1b2(%rip), %r15     # 0x341d8
leaq 0x184bc(%rip), %rsi     # 0x204e9
movq %r15, %rdi
callq 0x41b0
testl %eax, %eax
je 0x806d
movq %r15, %rdi
callq 0x4110
leal (%r14,%rax), %edi
addl $0x4, %edi
callq 0x4739
movq %rax, %r14
movq 0x2c181(%rip), %rdx     # 0x341d8
leaq 0x1986f(%rip), %rsi     # 0x218cd
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x42a0
jmp 0x8086
incl %r14d
movl %r14d, %edi
callq 0x4739
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, 0x2c14b(%rip)     # 0x341d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8c52
movl 0x1c(%rdi), %eax
cmpl $0x23, %eax
je 0x8c5a
cmpl $0x4, %eax
jne 0x8c62
leaq 0x192ab(%rip), %rax     # 0x21efc
retq
leaq 0x18e41(%rip), %rax     # 0x21a9a
retq
leaq 0x19293(%rip), %rax     # 0x21ef4
retq
pushq %r14
pushq %rbx
pushq %rax
andq $0x0, 0x2e702(%rip)     # 0x37370
andl $0x0, 0x2e703(%rip)     # 0x37378
leaq 0x2dd5c(%rip), %r14     # 0x369d8
movl $0x1, (%r14)
movb $0x0, 0x2e6f6(%rip)     # 0x37380
leaq 0x2e6ef(%rip), %rbx     # 0x37380
callq 0x8cbf
andl $0x0, (%r14)
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0x8ca8
testl %eax, %eax
jne 0x8cab
jmp 0x8cb0
movb $0x27, (%rbx)
incq %rbx
jmp 0x8c9a
leaq 0x2e6c9(%rip), %rax     # 0x37380
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa4ad
movl 0x1c(%rdi), %eax
cmpl $0x4, %eax
je 0xa4ad
cmpl $0x23, %eax
jne 0xa4b5
leaq 0x19add(%rip), %rax     # 0x23f91
retq
pushq %rbp
pushq %r14
pushq %rbx
andl $0x0, 0x2ceb8(%rip)     # 0x37378
leaq 0x2c511(%rip), %r14     # 0x369d8
movl $0x1, (%r14)
xorl %ebp, %ebp
movb %bpl, 0x2cea9(%rip)     # 0x37380
leaq 0x2cea2(%rip), %rbx     # 0x37380
callq 0x8cbf
andl $0x0, (%r14)
movb %bpl, 0x29ea4(%rip)     # 0x34392
movw $0x2d2d, 0x29e99(%rip)  # imm = 0x2D2D
movb %bpl, 0x2de82(%rip)     # 0x38380
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa50a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
leaq 0x17a04(%rip), %rsi     # 0x21f29
leaq 0x29e64(%rip), %rdx     # 0x34390
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x42a0
movq 0x2ee40(%rip), %rax     # 0x39380
movq %rax, 0x2ee41(%rip)     # 0x39388
andq $0x0, 0x2ee31(%rip)     # 0x39380
movq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xa580
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0xa796
addq %r12, %r15
jmp 0xa552
leaq 0x179aa(%rip), %r14     # 0x21f31
pushq $0x4
popq %rbp
movq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xa5b0
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0xa796
addq $0x4, %r15
jmp 0xa58d
movq 0x2edc9(%rip), %r12     # 0x39380
testq %r12, %r12
je 0xa605
leaq 0x2ddbd(%rip), %r14     # 0x38380
testq %r12, %r12
je 0xa5f3
movq (%r12), %r13
movq %r13, %r15
subq %rbx, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4090
addq %r15, %r14
movswq 0x8(%r12), %rbx
addq %r13, %rbx
movq 0x10(%r12), %r12
jmp 0xa5c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x2dd7b(%rip), %rbx     # 0x38380
movq %rbx, %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/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, %r12
movq %rdi, %rbx
leaq 0x178c6(%rip), %r14     # 0x21f04
leaq 0x178cf(%rip), %r15     # 0x21f14
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xa681
movq %rax, %r13
movb $0x0, (%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4170
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41c0
movb $0x5f, (%r13)
addq $0xf, %r13
movq %r13, %r12
jmp 0xa645
movq %r12, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x25
popq %rsi
movq %r15, %rdi
callq 0x4130
testq %rax, %rax
je 0xa6bf
cmpb $0x25, 0x1(%rax)
jne 0xa72c
leaq 0x17853(%rip), %r12     # 0x21f19
leaq 0x17849(%rip), %r13     # 0x21f16
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
testq %rax, %rax
je 0xa708
movq %rax, %rbp
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa628
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x41c0
movb $0x5f, (%rbp)
addq $0xf, %rbp
movq %rbp, %r15
jmp 0xa6cd
movq %r14, %rdi
movq %r15, %rsi
callq 0xa628
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_O2/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:
leaq 0x2ec3e(%rip), %rdx     # 0x39380
xorl %eax, %eax
movq (%rdx), %rcx
testq %rcx, %rcx
je 0xa75d
movq (%rdi), %rdx
cmpq (%rcx), %rdx
jb 0xa771
leaq 0x10(%rcx), %rdx
movq %rcx, %rax
jmp 0xa744
leaq 0x10(%rax), %rcx
testq %rax, %rax
leaq 0x2ec15(%rip), %rax     # 0x39380
cmovneq %rcx, %rax
jmp 0xa792
testq %rax, %rax
je 0xa780
movq %rcx, 0x10(%rdi)
addq $0x10, %rax
jmp 0xa792
leaq 0x2ebf9(%rip), %rax     # 0x39380
movq 0x2ebf2(%rip), %rcx     # 0x39380
movq %rcx, 0x10(%rdi)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ebe2(%rip), %rdi     # 0x39388
testq %rdi, %rdi
je 0xa7b8
movq 0x10(%rdi), %rax
movq %rax, 0x2ebd2(%rip)     # 0x39388
jmp 0xa7c3
pushq $0x18
popq %rdi
callq 0x4739
movq %rax, %rdi
movq %r14, (%rdi)
movw %bx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa73b
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rdi
callq 0x4739
movq %rax, %r14
movq %r15, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r14)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movl 0x2eb7b(%rip), %eax     # 0x39390
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2eb59(%rip), %rax     # 0x39398
movq %rax, 0x38(%r14)
movq %r14, 0x2eb4e(%rip)     # 0x39398
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rdi
callq 0x4739
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl 0x2eb0a(%rip), %eax     # 0x39390
movl %eax, 0x2c(%r14)
movq 0x2eb0f(%rip), %rax     # 0x393a0
movq %rax, 0x38(%r14)
movq %r14, 0x2eb04(%rip)     # 0x393a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x2eae5(%rip), %r15     # 0x39398
leaq 0x1767c(%rip), %r14     # 0x21f36
movq (%r15), %r15
testq %r15, %r15
je 0xa8e4
cmpl $0x0, 0x2c(%r15)
jne 0xa8de
movq (%r15), %rdx
cmpb $0x28, (%rdx)
je 0xa8de
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
addq $0x38, %r15
jmp 0xa8ba
leaq 0x2eab5(%rip), %r15     # 0x393a0
leaq 0x17651(%rip), %r14     # 0x21f43
movq (%r15), %r15
testq %r15, %r15
je 0xa917
cmpl $0x0, 0x2c(%r15)
jne 0xa911
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
addq $0x38, %r15
jmp 0xa8f2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: add_substitute
void
add_substitute(char *s, char *t)	/* substitute rules defined in lut */
{	Fcts *f;

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xa991
movq %r14, %rdi
callq 0xa9ba
movq %rax, %r14
movl 0x2ea48(%rip), %eax     # 0x39390
movl %eax, 0x2c(%r14)
testq %rbx, %rbx
je 0xa972
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
jmp 0xa977
andq $0x0, 0x8(%r14)
movq 0x2ea2a(%rip), %rax     # 0x393a8
movq %rax, 0x38(%r14)
movq %r14, 0x2ea1f(%rip)     # 0x393a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x29660(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x297fe(%rip), %rax     # 0x341a0
movq (%rax), %rdx
leaq 0x175a3(%rip), %rsi     # 0x21f4f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: modex_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
pushq $0x40
popq %rdi
callq 0x4739
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 0x4739
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x2c065(%rip), %rax     # 0x36a68
cmpl $0x0, (%rax)
je 0xaa11
movl $0x1, 0x28(%rbx)
jmp 0xaa2b
leaq 0x29790(%rip), %rax     # 0x341a8
movq (%rax), %rsi
leaq 0x2996e(%rip), %rdi     # 0x34390
callq 0x41b0
testl %eax, %eax
je 0xaa08
cmpl $0x0, 0x2e986(%rip)     # 0x393b8
jle 0xaa3d
movl $0x1, 0x30(%rbx)
jmp 0xaa65
cmpl $0x0, 0x2e978(%rip)     # 0x393bc
jle 0xaa4f
movl $0x2, 0x30(%rbx)
jmp 0xaa65
cmpl $0x0, 0x2e96a(%rip)     # 0x393c0
jle 0xaa61
movl $0x3, 0x30(%rbx)
jmp 0xaa65
andl $0x0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab67
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2e91d(%rip), %r12     # 0x393b0
movq (%r12), %r12
testq %r12, %r12
je 0xaae1
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xaadb
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xab5f
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0xaadb
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xab5f
addq $0x38, %r12
jmp 0xaa93
movq %r15, %rdi
callq 0xa9ba
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 0xab68
movq %rax, %rbx
movq %rax, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x29862(%rip), %rbx     # 0x34390
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x2e85c(%rip), %rax     # 0x393b0
movq %rax, 0x38(%r15)
movq %r15, 0x2e851(%rip)     # 0x393b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2a
popq %rsi
callq 0x4130
testq %rax, %rax
jne 0xab8f
pushq $0x5b
popq %rsi
movq %rbx, %rdi
callq 0x4130
testq %rax, %rax
je 0xac0c
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x3983b(%rip), %r14     # 0x443f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
pushq $0x2a
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4130
testq %rax, %rax
je 0xabd7
movb $0x20, (%rax)
jmp 0xabc3
leaq 0x39812(%rip), %rdi     # 0x443f0
pushq $0x5b
popq %rsi
callq 0x4130
testq %rax, %rax
je 0xabee
movb $0x0, (%rax)
callq 0x42e0
movq (%rax), %rax
leaq 0x397f2(%rip), %rbx     # 0x443ef
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xabfd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x0, (%rdi)
je 0xaefa
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0xaeec
movl %edx, %r15d
movq %rdi, %r14
movl %ecx, 0x4(%rsp)
movb $0x1, %al
movl %eax, (%rsp)
leaq 0x2e5d9(%rip), %rbp     # 0x393c8
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xae53
movq (%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x42d0
testq %rax, %rax
je 0xae4d
movq %rax, %r12
cmpq %rbx, %rax
jne 0xae3d
movq %r13, %rdi
callq 0x4110
movzbl (%r12,%rax), %eax
leal -0x20(%rax), %ecx
cmpl $0x3d, %ecx
ja 0xae39
movabsq $0x2800000000000001, %rdx # imm = 0x2800000000000001
btq %rcx, %rdx
jb 0xae7b
testl %eax, %eax
je 0xae7b
cmpb $0x2a, -0x2(%r12)
jne 0xae4d
cmpb $0x20, -0x1(%r12)
je 0xae7b
addq $0x38, %rbp
jmp 0xadef
testb $0x1, (%rsp)
movl 0x4(%rsp), %ecx
je 0xaeec
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0xac17
movl $0x0, (%rsp)
jmp 0xade8
movq 0x18(%rbp), %r15
testq %r15, %r15
je 0xae93
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0xaeec
leaq 0x2bbe2(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
je 0xaeb6
leaq 0x17108(%rip), %rdi     # 0x21fae
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x4140
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
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 0xaeec
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_O2/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
leaq 0x2d07f(%rip), %rbp     # 0x393c8
leaq 0x15d24(%rip), %r14     # 0x22074
leaq 0x15c3d(%rip), %r15     # 0x21f94
leaq 0x15d1e(%rip), %r12     # 0x2207c
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xc3a5
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc39f
movq %r13, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc39f
movq (%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41c0
addq $0x38, %rbp
jmp 0xc35e
leaq 0x2d004(%rip), %r12     # 0x393b0
leaq 0x15cc1(%rip), %r14     # 0x22074
leaq 0x15bda(%rip), %r15     # 0x21f94
leaq 0x15cc9(%rip), %r13     # 0x2208a
movq (%r12), %r12
testq %r12, %r12
je 0xc410
movq 0x10(%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc40a
movq %rbp, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc40a
movq (%r12), %r8
movq %rbx, %rdi
leaq 0x15c9c(%rip), %rsi     # 0x22099
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x41c0
addq $0x38, %r12
jmp 0xc3c1
leaq 0x2cfb9(%rip), %rbp     # 0x393d0
leaq 0x15c56(%rip), %r14     # 0x22074
leaq 0x15b6f(%rip), %r15     # 0x21f94
leaq 0x15c67(%rip), %r12     # 0x22093
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xc477
movq 0x10(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc471
movq %r13, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xc471
movq (%rbp), %rcx
movq 0x8(%rbp), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x41c0
addq $0x38, %rbp
jmp 0xc42c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: spintype
char *
spintype(char *s, char *t)
{	static struct {
		char *tp; char *mp;
	} StS[] = {
		{ "bit ",	"bit" },	/* trailing space */
		{ "bool ",	"bool" },
		{ "byte ", 	"byte" },
		{ "pid ", 	"pid" },
		{ "int ",	"int" },
		{ "short ",	"short" },
		{ "uchar ", 	"byte" },
		{ "chan ", 	"chan" },

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

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

	return (char *) 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x26f12(%rip), %r12     # 0x333b0
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq $0x110, %r13            # imm = 0x110
je 0xc53b
movq (%rcx,%r12), %rsi
movq %r15, %rdi
callq 0x41b0
movq %r13, %rcx
testl %eax, %eax
jne 0xc4a0
movq -0x8(%r13,%r12), %rbx
testq %r14, %r14
je 0xc53b
leaq 0x15c15(%rip), %rsi     # 0x220ea
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0xc53b
pushq $0x2a
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
jne 0xc539
leaq 0x15bfd(%rip), %rsi     # 0x220f5
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0xc539
leaq 0x16715(%rip), %rsi     # 0x22c21
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0xc539
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
jne 0xc539
pushq $0x7b
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
je 0xc548
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x5b
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
je 0xc53b
movq %rax, %r15
pushq $0x5b
popq %rsi
movq %r14, %rdi
callq 0x4150
cmpq %rax, %r15
jne 0xc539
pushq $0x3d
popq %rsi
movq %r14, %rdi
callq 0x4130
xorl %ecx, %ecx
testq %rax, %rax
cmovneq %rcx, %rbx
jmp 0xc53b
// File: /workspace/github_c_makefile_star2_O2/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 0xc7c0
pushq $0x3d
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x4130
testq %rax, %rax
je 0xc7c0
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0xc7a7
cmpl $0x20, %eax
je 0xc7a7
testl %eax, %eax
jne 0xc7c5
movq %rbx, %r14
jmp 0xc826
xorl %r14d, %r14d
jmp 0xc826
movq %rbx, %rdi
callq 0x4110
leal 0x1(,%rax,2), %edi
callq 0x4739
movq %rax, %r14
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x4130
movq %r14, %rcx
testq %rax, %rax
je 0xc80b
movq %r14, %rcx
incq %rcx
movb $0x7b, (%r14)
jmp 0xc80b
movb $0x5c, (%rcx)
incq %rcx
movb (%rbx), %al
movb %al, (%rcx)
incq %rcx
incq %rbx
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0xc7fb
testl %eax, %eax
jne 0xc803
cmpb $0x7b, (%r14)
jne 0xc823
movb $0x7d, (%rcx)
incq %rcx
movb $0x0, (%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4130
testq %rax, %rax
je 0xc84f
movb $0x20, (%rax)
jmp 0xc83b
leaq 0x1396d(%rip), %r14     # 0x201c3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xc86d
movw $0x2020, (%rax)         # imm = 0x2020
jmp 0xc856
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: imported
int
imported(char *p, char *q, int about_to_generate)
{	Spress *s;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2ff8e(%rip), %rbp     # 0x3caa0
leaq 0x14e02(%rip), %r12     # 0x2191b
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xcb7c
movq 0x8(%rbp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x41b0
testl %eax, %eax
je 0xcb44
movq %r13, %rdi
movq %r12, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xcb66
movq (%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x41b0
testl %eax, %eax
je 0xcb6c
movq %r13, %rdi
movq %r12, %rsi
callq 0x41b0
testl %eax, %eax
je 0xcb6c
addq $0x20, %rbp
jmp 0xcb19
movl $0x1, 0x10(%rbp)
testl %ebx, %ebx
je 0xcb80
movl 0x14(%rbp), %eax
jmp 0xcb83
xorl %eax, %eax
jmp 0xcb83
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: add_fnm
void
add_fnm(char *s)
{	NameL *nl;

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

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

	tbuf[0] = '\0';
}

// Assembly:
testq %rdi, %rdi
je 0xd0eb
pushq %rbx
leaq 0x2994f(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0xd0ea
movq %rdi, %rbx
movq 0x2a2d8(%rip), %rdi     # 0x37370
testq %rdi, %rdi
je 0xd0ea
leaq 0x29bf8(%rip), %rax     # 0x36c9c
cmpl $0x0, (%rax)
jne 0xd0ea
leaq 0x299c0(%rip), %rax     # 0x36a70
cmpl $0x0, (%rax)
jne 0xd0ea
leaq 0x29bf0(%rip), %rax     # 0x36cac
cmpl $0x0, (%rax)
jne 0xd0ea
leaq 0x16ec9(%rip), %rdx     # 0x23f91
movq %rbx, %rsi
callq 0xa695
leaq 0x159bb(%rip), %rsi     # 0x22a92
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0xd0ea
incl 0x360ba(%rip)           # 0x431a4
popq %rbx
movb $0x0, 0x2e50e(%rip)     # 0x3b600
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: x_scopetab
void
x_scopetab(scopetab_t *that, FILE *fpp, char *want)
{	scopetab_t *z;
	int j;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0xd153
cmpl $0x4, 0x4(%r15)
jl 0xd153
movq %r15, %r13
movq 0x10(%r13), %r13
testq %r13, %r13
je 0xd153
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0xd118
cmpb $0x2d, (%rdi)
jne 0xd135
cmpb $0x0, 0x1(%rdi)
je 0xd118
cmpl $0x1, 0x20(%r13)
jne 0xd118
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xd118
movq %r12, %rdi
movq %r14, %rsi
callq 0x131f9
xorl %r12d, %r12d
movslq 0x28(%r15), %rax
cmpq %rax, %r12
jge 0xd177
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd0f3
incq %r12
jmp 0xd156
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: ax_doprops
void
ax_doprops(FILE *fd, scopetab_t *that)
{	Ax_Props *p;

	if (ax_prop_nr == 0) return;

	ax_fixed(fd);

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

// Assembly:
cmpl $0x0, 0x37248(%rip)     # 0x443d0
je 0xd1cb
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12f2b
leaq 0x37237(%rip), %r15     # 0x443d8
movq (%r15), %r15
testq %r15, %r15
je 0xd1c6
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x13112
movq %r14, %rdi
movq %r15, %rsi
callq 0x12e8f
addq $0x20, %r15
jmp 0xd1a1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: def_inc_spn
void
def_inc_spn(FILE *fd)
{	NameL *nl;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2e1fd(%rip), %r13     # 0x3b5e8
leaq 0x1509f(%rip), %r14     # 0x22491
leaq 0x1509d(%rip), %r15     # 0x22496
movq (%r13), %r13
testq %r13, %r13
je 0xd42c
movq (%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0xd426
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41c0
addq $0x10, %r13
jmp 0xd3f9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: new_globchan
void
new_globchan(char *s)
{	NameL *nl;

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2f0ef(%rip), %r15     # 0x3caa0
movq (%r15), %r15
testq %r15, %r15
je 0xd9e2
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xd9dc
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0xda72
addq $0x20, %r15
jmp 0xd9b1
pushq $0x28
popq %rdi
callq 0x4739
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r15)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x40b0
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x40b0
andl $0x0, 0x10(%r15)
movl %ebp, 0x14(%r15)
movq 0x2f065(%rip), %rax     # 0x3caa0
movq %rax, 0x20(%r15)
movq %r15, 0x2f05a(%rip)     # 0x3caa0
leaq 0x13ece(%rip), %rsi     # 0x2191b
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xda72
leaq 0x13ebb(%rip), %rsi     # 0x2191b
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xda72
incl 0x2f022(%rip)           # 0x3ca94
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq