LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: do_parameters
void
do_parameters(void)
{	Fcts *g;
	char *z;
	char xx[128];

	if (suppress || globals_only)
	{	return;
	}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x2922b(%rip), %rax     # 0x36cc0
leaq 0x29200(%rip), %rcx     # 0x36c9c
movl (%rcx), %ecx
orl (%rax), %ecx
je 0xdab4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b915(%rip), %r15     # 0x393d0
leaq 0x268ce(%rip), %rbx     # 0x34390
movq (%r15), %r15
testq %r15, %r15
je 0xdb08
cmpl $0x2, 0x30(%r15)
jne 0xdb02
movq 0x8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xdb02
movq 0x18(%r15), %rsi
testq %rsi, %rsi
jne 0xdaf0
movq (%r15), %rsi
movq 0x10(%r15), %rdi
callq 0xc486
testq %rax, %rax
je 0xdbed
addq $0x38, %r15
jmp 0xdac2
leaq 0x2b8c1(%rip), %r12     # 0x393d0
leaq 0x2687a(%rip), %rbx     # 0x34390
leaq 0x2669b(%rip), %r13     # 0x341b8
leaq 0x13796(%rip), %r14     # 0x212ba
movq %rsp, %r15
movq (%r12), %r12
testq %r12, %r12
je 0xdaa2
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xdbe4
cmpl $0x2, 0x30(%r12)
jne 0xdbe4
movq 0x18(%r12), %rsi
testq %rsi, %rsi
jne 0xdb63
movq (%r12), %rsi
movq 0x10(%r12), %rdi
callq 0xc486
testq %rax, %rax
je 0xdbe4
movq %rax, %rbp
cmpl $0x0, 0x2ef14(%rip)     # 0x3ca90
je 0xdb8a
leaq 0x1458d(%rip), %rdi     # 0x22112
callq 0xd07c
movq (%r13), %rdi
movq %r14, %rsi
callq 0x41b0
movq 0x18(%r12), %rcx
testl %eax, %eax
je 0xdbbe
testq %rcx, %rcx
jne 0xdba8
movq (%r12), %rcx
movq %r15, %rdi
leaq 0x14a9e(%rip), %rsi     # 0x22650
movq %rbp, %rdx
xorl %eax, %eax
callq 0x42a0
jmp 0xdbd2
testq %rcx, %rcx
jne 0xdbc7
movq (%r12), %rcx
movq %r15, %rdi
movq %rcx, %rsi
callq 0x40b0
movq %r15, %rdi
callq 0xd07c
movl $0x1, 0x2eeac(%rip)     # 0x3ca90
addq $0x38, %r12
jmp 0xdb27
leaq 0x28e88(%rip), %rax     # 0x36a7c
cmpl $0x0, (%rax)
je 0xdaa2
movq 0x263f4(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x14a1c(%rip), %rsi     # 0x2262a
movq %r14, %rdx
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: map_type
int
map_type(char *s, symentry_t *nmtbl)
{	Fcts *f = (Fcts *) 0;
	int ret_val = 0;	/* 0 = undefined */

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl (%rsi), %eax
pushq $0x3
popq %rbx
cmpl $0x4, %eax
jne 0xe095
movq %rsi, %r15
movq %r14, %rdi
callq 0x5770
testl %eax, %eax
jne 0xe19e
movl (%r15), %eax
cmpl $0x3, %eax
jne 0xe11f
leaq 0x2b32b(%rip), %r13     # 0x393d0
leaq 0x262e4(%rip), %r15     # 0x34390
movq (%r13), %r13
testq %r13, %r13
je 0xe0e2
movq (%r13), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xe0dc
movq 0x8(%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x41b0
testl %eax, %eax
je 0xe161
addq $0x38, %r13
jmp 0xe0ac
leaq 0x2b2df(%rip), %r15     # 0x393c8
movq (%r15), %r15
testq %r15, %r15
je 0xe11f
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
addq $0x38, %r15
testl %eax, %eax
jne 0xe0e9
leaq 0x11fab(%rip), %rsi     # 0x200b6
xorl %ebx, %ebx
movq %r14, %rdi
xorl %edx, %edx
callq 0xcaf8
cmpl $0x1, %eax
adcl $0x2, %ebx
jmp 0xe19e
leaq 0x2b28a(%rip), %r12     # 0x393b0
leaq 0x11f89(%rip), %r15     # 0x200b6
movq (%r12), %r12
testq %r12, %r12
je 0xe15d
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
je 0xe157
movq (%r12), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0xe19e
addq $0x38, %r12
jmp 0xe12d
xorl %ebx, %ebx
jmp 0xe19e
leaq 0x26040(%rip), %rax     # 0x341a8
movq (%rax), %rsi
leaq 0x2621e(%rip), %rdi     # 0x34390
callq 0x41b0
testl %eax, %eax
jne 0xe183
movl $0x1, 0x28(%r13)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xcaf8
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x1(,%rcx,2), %ebx
movl %ebx, %eax
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: dump_substitute
void
dump_substitute(FILE *fd)
{	Fcts *f;
	for (f = maps; f; f = f->nxt)
	{	if (f->level > 0)
			continue;
		if (f->tg)
			fprintf(fd, "Substitute	%s	%s\n", f->nm, f->tg);
		else
			fprintf(fd, "Substitute	%s\n", f->nm);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2b1ec(%rip), %r12     # 0x393a8
leaq 0x14595(%rip), %r14     # 0x22758
leaq 0x1457c(%rip), %r15     # 0x22746
movq (%r12), %r12
testq %r12, %r12
je 0xe208
cmpl $0x0, 0x2c(%r12)
jg 0xe202
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rbx, %rdi
testq %rcx, %rcx
je 0xe1f8
movq %r15, %rsi
xorl %eax, %eax
callq 0x41c0
jmp 0xe202
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
addq $0x38, %r12
jmp 0xe1ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: via_substitute
void
via_substitute(char *into, char *z)
{	char *q, nbuf[BigEnough];
	Fcts *f;
if (0) fprintf(stderr, "via_sub '%s'\n", into);
	strcpy(into, z);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40b0
cmpl $0x0, 0x2b188(%rip)     # 0x393bc
je 0xe287
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0xe239
leaq 0x13d3d(%rip), %rsi     # 0x21f88
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
jne 0xe287
addq $0x4, %r14
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0xe26c
cmpl $0x2a, %eax
jne 0xe271
incq %r14
jmp 0xe25e
testl %eax, %eax
jne 0xe287
movb $0x0, (%rbx)
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2b11a(%rip), %r12     # 0x393a8
movq %rsp, %r14
movq (%r12), %r12
testq %r12, %r12
jne 0xe2e1
jmp 0xe278
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
movq 0x8(%r12), %rsi
testq %rsi, %rsi
je 0xe2bf
movq %r14, %rdi
callq 0x4290
movq (%r12), %rdi
callq 0x4110
addq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40b0
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
jne 0xe29c
addq $0x38, %r12
jmp 0xe291
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: add_external
void
add_external(char *p, char *q)
{	Spress *s;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e79e(%rip), %r15     # 0x3caa8
movq (%r15), %r15
testq %r15, %r15
je 0xe337
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
jne 0xe331
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0xe397
addq $0x20, %r15
jmp 0xe30a
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)
movq 0x2e71c(%rip), %rax     # 0x3caa8
movq %rax, 0x20(%r15)
movq %r15, 0x2e711(%rip)     # 0x3caa8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: nextarg
char*
nextarg(char *p)
{
	while (*p && /* *p != ' ' && */ *p != '\t')
		p++;
	while (*p == ' ' || *p == '\t')
		*p++ = 0;
	return p;
}

// Assembly:
movq %rdi, %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0xe3ba
testl %ecx, %ecx
je 0xe3ba
incq %rax
jmp 0xe3a0
movb $0x0, (%rax)
movb 0x1(%rax), %cl
incq %rax
cmpb $0x20, %cl
je 0xe3b1
movzbl %cl, %ecx
cmpl $0x9, %ecx
je 0xe3b1
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: add_constants
void
add_constants(char *p)
{	char *q;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe39d
cmpb $0x0, (%rax)
je 0xe3de
movq %rax, %rdi
callq 0xe3c8
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x56f8
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: notimported
void
notimported(FILE *fd)
{	Spress *s;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2e6a3(%rip), %r13     # 0x3caa0
leaq 0x11cb2(%rip), %r14     # 0x200b6
leaq 0x1435c(%rip), %r15     # 0x22767
movq (%r13), %r13
testq %r13, %r13
je 0xe449
cmpl $0x0, 0x10(%r13)
jne 0xe443
movq 0x8(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xe443
movq (%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x41c0
addq $0x20, %r13
jmp 0xe40b
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: read_more
void
read_more(FILE *fd, char *buf)
{	char *p, more[1024];


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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movabsq $0x100002600, %r13      # imm = 0x100002600
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x4190
testq %rax, %rax
je 0xe500
movq %rbx, %rdi
callq 0x4110
movb $0x0, -0x1(%rbx,%rax)
movq %r15, %rdi
callq 0x4110
addq %r15, %rax
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0xe4bd
btq %rcx, %r13
jae 0xe4bd
movb $0x0, (%rax)
decq %rax
jmp 0xe4a6
movq %r15, %r12
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0xe4cf
cmpl $0x9, %eax
jne 0xe4d4
incq %r12
jmp 0xe4c0
movq %rbx, %rdi
callq 0x4110
movw $0x20, (%rbx,%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4290
movq %rbx, %rdi
callq 0x4110
cmpb $0x5c, -0x1(%rbx,%rax)
je 0xe476
addq $0x400, %rsp            # imm = 0x400
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: get_defaults
void
get_defaults(char *lut)
{	Cache *c;

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

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

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

	Down -= 2;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2d8f1(%rip), %rax     # 0x3cab8
movq (%rax), %rax
testq %rax, %rax
je 0xf1d9
orb $0x5, 0x14(%rax)
addq $0x20, %rax
jmp 0xf1c7
leaq 0x27ad0(%rip), %r14     # 0x36cb0
movq (%r14), %rsi
testq %rsi, %rsi
je 0xf1f8
leaq 0x14da2(%rip), %rdi     # 0x23f91
callq 0xe511
andq $0x0, (%r14)
movl 0x2a192(%rip), %ebp     # 0x39390
incl %ebp
movl %ebp, 0x2a18a(%rip)     # 0x39390
leaq 0x13795(%rip), %rsi     # 0x229a2
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0xf232
leaq 0x14d71(%rip), %rdi     # 0x23f91
leaq 0x1377b(%rip), %rsi     # 0x229a2
callq 0xe511
movl 0x2a15e(%rip), %ebp     # 0x39390
incl %ebp
movl %ebp, 0x2a156(%rip)     # 0x39390
leaq 0x14d50(%rip), %rdi     # 0x23f91
leaq 0x13766(%rip), %rsi     # 0x229ae
callq 0xe511
addl $-0x2, 0x2a13c(%rip)    # 0x39390
leaq 0x2d85d(%rip), %rax     # 0x3cab8
pushq $0x1
popq %rcx
movq (%rax), %rax
testq %rax, %rax
je 0xf27d
movl 0x14(%rax), %edx
movl %edx, %esi
andl $-0x6, %esi
testb $0x5, %dl
cmovel %ecx, %esi
movl %esi, 0x14(%rax)
addq $0x20, %rax
jmp 0xf25e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: add_padding
void
add_padding(FILE *lf, char *s)
{	int j;
	j = strlen(s);
	if (j < 40) fprintf(lf, "\t");
	if (j < 32) fprintf(lf, "\t");
	if (j < 24) fprintf(lf, "\t");
	if (j < 16) fprintf(lf, "\t");
	if (j <  8) fprintf(lf, "\t");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4110
movq %rax, %r14
cmpl $0x27, %r14d
jg 0xf2f0
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x4180
cmpl $0x1f, %r14d
jg 0xf2f0
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x4180
cmpl $0x17, %r14d
jg 0xf2f0
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x4180
cmpl $0xf, %r14d
jg 0xf2f0
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x4180
cmpl $0x7, %r14d
jg 0xf2f0
pushq $0x9
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: dump_lut
void
dump_lut(void)
{	int n;
	FILE *lf;
	char nlutfl[512];
	static char *prefs[] =
	{ "D: ", "C: ", "A: ", "F: ", "R: ", "case ", "", 0 };

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

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

	if (Verbose&2)
		dump_decls(stdout);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x24ce4(%rip), %r12     # 0x341a8
movq (%r12), %rdx
leaq 0x24cc9(%rip), %rax     # 0x34198
movq (%rax), %rcx
leaq 0x13510(%rip), %rsi     # 0x229e9
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42a0
movq 0x24b0b(%rip), %r14     # 0x33ff8
movq (%r14), %rdi
leaq 0x24ca9(%rip), %r15     # 0x341a0
movq (%r15), %rdx
leaq 0x134ee(%rip), %rsi     # 0x229ef
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
leaq 0x182dd(%rip), %rsi     # 0x277ef
movq %rbx, %rdi
callq 0x4270
testq %rax, %rax
je 0xf5c7
movq %rax, %rbx
leaq 0x274eb(%rip), %r15     # 0x36a18
cmpl $0x0, (%r15)
jne 0xf5e0
movq (%r12), %rcx
leaq 0x12418(%rip), %rsi     # 0x2195a
leaq 0x12425(%rip), %rdx     # 0x2196e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movq %rbx, %rdi
callq 0xa8a4
movq %rbx, %rdi
callq 0xe1aa
leaq 0x27512(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
je 0xf57e
movq 0x24a5a(%rip), %rax     # 0x33fd0
movq (%rax), %rdi
callq 0xc334
xorl %r12d, %r12d
leaq 0x23fb8(%rip), %r13     # 0x33540
cmpq $0x38, %r12
je 0xf5a0
movq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0xf2f8
addq $0x8, %r12
jmp 0xf588
cmpl $0x0, (%r15)
jne 0xf5fc
movq %rbx, %rdi
callq 0x59e0
movq %rsp, %rdi
callq 0xcb92
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq (%r15), %rdx
leaq 0x1342b(%rip), %rsi     # 0x229ff
movq %rsp, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0xf5b6
movq (%r14), %rdi
leaq 0x12d19(%rip), %rsi     # 0x22303
movq %rsp, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0xf537
movq (%r14), %rdi
leaq 0x1340f(%rip), %rsi     # 0x22a15
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
jmp 0xf5a6
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: check_lut
void
check_lut(FILE *fd)
{	Cache *c;
	int identified = 0;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2d490(%rip)     # 0x3cab8
jne 0xf645
leaq 0x24b6f(%rip), %rax     # 0x341a0
movq (%rax), %rdx
leaq 0x133e6(%rip), %rsi     # 0x22a21
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
leaq 0x2d46c(%rip), %r12     # 0x3cab8
leaq 0x24b55(%rip), %r13     # 0x341a8
leaq 0x133df(%rip), %r14     # 0x22a39
leaq 0x133df(%rip), %r15     # 0x22a40
pushq $0x1
popq %rbp
xorl %eax, %eax
movq (%r12), %r12
testq %r12, %r12
je 0xf6aa
cmpl $0x0, 0x14(%r12)
jne 0xf6a4
testl %eax, %eax
jne 0xf68c
movq (%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41c0
movl %ebp, %eax
addq $0x20, %r12
jmp 0xf666
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: modex_mark
void
modex_mark(treenode *n, int how)
{
	if (!n || !n->hdr.defuse) return;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf73d
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xf73d
movl %esi, %ebx
leaq 0x27399(%rip), %r12     # 0x36a7c
testb $0x2, (%r12)
je 0xf725
leaq 0x2bf0f(%rip), %r15     # 0x3b600
leaq 0x1335a(%rip), %rsi     # 0x22a52
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x42a0
movq %r15, %rdi
callq 0xd07c
movq 0x20(%r14), %rdi
movq 0x248b9(%rip), %rax     # 0x33fd0
movq (%rax), %rdx
xorl %esi, %esi
callq 0x1c8f4
movq 0x20(%r14), %rdi
movq 0x248cc(%rip), %rax     # 0x33ff8
movq (%rax), %rdx
movl %ebx, %esi
callq 0x1c7ed
testb $0x2, (%r12)
jne 0xf749
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x134f4(%rip), %rdi     # 0x22c44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd07c
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: form_c_tag
char *
form_c_tag(char *frst, int i, char *lst)
{	char *p;
	int j = strlen(frst)+strlen(OutBuf)-i+strlen(lst)+strlen(" }")+1;
	p = (char *) e_malloc(j*sizeof(char));
	sprintf(p, "%s%s%s }", frst, &OutBuf[i], lst);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x4110
movq %rax, %r12
leaq 0x27bfe(%rip), %r15     # 0x37380
movq %r15, %rdi
callq 0x4110
movq %rax, %r13
movslq %ebp, %rbp
movq %rbx, %rdi
callq 0x4110
subl %ebp, %r12d
addl %r12d, %r13d
leal (%rax,%r13), %edi
addl $0x3, %edi
callq 0x4739
movq %rax, %r12
addq %rbp, %r15
leaq 0x132a5(%rip), %rsi     # 0x22a5c
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x42a0
movq %r12, %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: do_mine
void
do_mine(SymList *s)
{	char mine[BigEnough];
	if (s->mark)
	{	sprintf(mine, "	%s = %s | %d;\n",
			s->sm->nme->str,
			s->sm->nme->str,
			s->mark&(DEF|USE|
			FCALL|REF0|REF1|REF2|DEREF|
			ALIAS|ARRAY_DECL|HIDE|DECL|
			USEafterdef|USEbeforedef|PARAM));
		vis_direct(mine);
	}
}

// Assembly:
movl 0x4(%rdi), %r8d
testl %r8d, %r8d
je 0xf827
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
andl $0x3fff, %r8d           # imm = 0x3FFF
leaq 0x1325e(%rip), %rsi     # 0x22a65
movq %rsp, %rbx
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x42a0
movq %rbx, %rdi
callq 0xd07c
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: do_dumode
char *
do_dumode(treenode *n)
{	SymList *s;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x29b85(%rip)     # 0x393b8
jne 0xf8a7
cmpl $0x0, 0x29b80(%rip)     # 0x393bc
jne 0xf8a7
cmpl $0x0, 0x2d287(%rip)     # 0x3cacc
jne 0xf8a7
movq %rdi, %rbx
testq %rdi, %rdi
je 0xf8b6
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0xf8a7
addq $0x8, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xf872
movq %r14, %rdi
callq 0xf7dc
addq $0x10, %r14
jmp 0xf85c
movq 0x20(%rbx), %r14
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xf889
movq %r14, %rdi
callq 0xf7dc
jmp 0xf876
movq 0x20(%rbx), %rbx
addq $0x18, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf8a7
movq %rbx, %rdi
callq 0xf7dc
addq $0x10, %rbx
jmp 0xf891
leaq 0x17c40(%rip), %rax     # 0x274ee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x131b8(%rip), %rdi     # 0x22a75
callq 0xd07c
callq 0x4060
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: replace_lut
static void
replace_lut(char *r, char *t)
{	Cache *c;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2cb31(%rip), %r12     # 0x3cab8
movq (%r12), %r12
testq %r12, %r12
je 0xffc1
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x41b0
testl %eax, %eax
jne 0xffbb
movq %r15, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
cmpq %rax, %r15
je 0xffe7
addq $0x20, %r12
jmp 0xff87
leaq 0x241d8(%rip), %rax     # 0x341a0
movq (%rax), %rsi
leaq 0x134e5(%rip), %rdi     # 0x234b7
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4140
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r12)
leaq 0x26a79(%rip), %rcx     # 0x36a7c
testb $0x2, (%rcx)
je 0x1002e
leaq 0x24191(%rip), %rcx     # 0x341a0
movq (%rcx), %rsi
leaq 0x13480(%rip), %rdi     # 0x23499
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x4140
movq 0x8(%r12), %rax
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: precondition
void
precondition(treenode *n)
{	PreC *p;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x4739
movq %rbx, (%rax)
movq 0x2fc76(%rip), %rcx     # 0x3fd08
movq %rcx, 0x8(%rax)
movq %rax, 0x2fc6b(%rip)     # 0x3fd08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: act_prec
void
act_prec(void)
{	PreC *p;
#if 0
	if (!prec)
	{	strcpy(PreBuf, "");
		return;
	}
#endif
if (0) fprintf(fp, "act prec\n");
	strcpy(Rem, OutBuf);	/* save */
	strcpy(OutBuf, "");

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2fc65(%rip), %rdi     # 0x3fd10
leaq 0x272ce(%rip), %rbx     # 0x37380
movq %rbx, %rsi
callq 0x40b0
movb $0x0, 0x272bf(%rip)     # 0x37380
leaq 0x2fc40(%rip), %r14     # 0x3fd08
movq (%r14), %r15
testq %r15, %r15
je 0x100f9
movq (%r15), %rdi
callq 0x8cbf
leaq 0x8(%r15), %r14
cmpq $0x0, 0x8(%r15)
je 0x100c8
movq %rbx, %rdi
callq 0x4110
movl $0x20262620, (%rax,%rbx) # imm = 0x20262620
movb $0x0, 0x4(%rax,%rbx)
jmp 0x100c8
cmpb $0x0, 0x27280(%rip)     # 0x37380
je 0x1011f
cmpb $0x0, 0x2a4d7(%rip)     # 0x3a5e0
je 0x1011f
movq %rbx, %rdi
callq 0x4110
movl $0x20262620, (%rax,%rbx) # imm = 0x20262620
movb $0x0, 0x4(%rax,%rbx)
leaq 0x2725a(%rip), %rbx     # 0x37380
leaq 0x2a4b3(%rip), %rsi     # 0x3a5e0
movq %rbx, %rdi
callq 0x4290
leaq 0x2c9a4(%rip), %rdi     # 0x3cae0
movq %rbx, %rsi
callq 0x40b0
leaq 0x2fbc5(%rip), %rsi     # 0x3fd10
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: vis_print
void
vis_print(char *nw)
{	char w0[1024], *w1, *w2;

	if (!visu || !nw) return;

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

// Assembly:
testq %rdi, %rdi
je 0x1079e
leaq 0x262d6(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0x1079e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rsi
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
callq 0x4090
pushq $0xa
popq %rbx
leaq 0x26c4a(%rip), %r14     # 0x37380
movq %r15, %rdi
movl %ebx, %esi
callq 0x4130
testq %rax, %rax
je 0x10781
movq %rax, %r12
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4290
movq %r14, %rdi
callq 0x4110
movw $0x5c, (%rax,%r14)
movq %r14, %rdi
callq 0x4110
movw $0x6e, (%rax,%r14)
movb $0xa, (%r12)
incq %r12
movq %r12, %r15
jmp 0x10736
leaq 0x26bf8(%rip), %rdi     # 0x37380
movq %r15, %rsi
callq 0x4290
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: vis_indent
void
vis_indent(int tb, char *s)	/* not via lookup table */
{	int j;

	if (!visu) return;

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

	vis_direct(s);
}

// Assembly:
leaq 0x26232(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0x107dd
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
subl 0x30562(%rip), %ebp     # 0x40d1c
leaq 0x12496(%rip), %r14     # 0x22c57
testl %ebp, %ebp
jle 0x107d1
movq %r14, %rdi
callq 0xd07c
decl %ebp
jmp 0x107c1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd07c
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: check_fct
void
check_fct(char *s, int tabs)
{	Fcts *f;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28ba9(%rip), %r15     # 0x39398
movq (%r15), %r15
testq %r15, %r15
je 0x1080d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0x10813
addq $0x38, %r15
jmp 0x107ef
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12440(%rip), %rsi     # 0x22c5a
movl %ebx, %edi
callq 0x1079f
movq 0x8(%r15), %rdi
callq 0xd07c
leaq 0x133c0(%rip), %rdi     # 0x23bf1
popq %rbx
popq %r14
popq %r15
jmp 0xd07c
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: push_dostack
void
push_dostack(treenode *tn)
{	char *nl;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x4739
movq %rax, %r14
movl 0x304cd(%rip), %edx     # 0x40d20
leal 0x1(%rdx), %eax
movl %eax, 0x304c4(%rip)     # 0x40d20
leaq 0x123fc(%rip), %rsi     # 0x22c5f
movq %r14, %rdi
xorl %eax, %eax
callq 0x42a0
movslq 0x26b04(%rip), %rax     # 0x37378
leaq 0x304b5(%rip), %rcx     # 0x40d30
movq %rbx, (%rcx,%rax,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x26af0(%rip)     # 0x37378
leaq 0x306a1(%rip), %rcx     # 0x40f30
movq %r14, (%rcx,%rax,8)
movq %r14, %rdi
callq 0xd07c
leaq 0x1a9ce(%rip), %rdi     # 0x2b270
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd07c
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: use_dostack
void
use_dostack(int tabs)
{
	if (do_level < 1 || do_level > MAXLEVEL)
	{	if (preview) return;
		fprintf(stderr, "dolevel error %d\n", do_level);
		exit(1);
	}

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

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

// Assembly:
pushq %rbx
movl 0x26ac3(%rip), %edx     # 0x37378
leal -0x41(%rdx), %eax
cmpl $-0x41, %eax
ja 0x108cb
leaq 0x26178(%rip), %rax     # 0x36a3c
cmpl $0x0, (%rax)
je 0x10919
popq %rbx
retq
movl %edi, %ebx
decl %edx
leaq 0x3045a(%rip), %rax     # 0x40d30
movq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
je 0x108e6
movl %ebx, %esi
callq 0x10939
leaq 0x12389(%rip), %rsi     # 0x22c76
movl %ebx, %edi
callq 0x1079f
movslq 0x26a7d(%rip), %rax     # 0x37378
leaq 0x3062e(%rip), %rcx     # 0x40f30
movq -0x8(%rcx,%rax,8), %rdi
callq 0xd07c
leaq 0x132e0(%rip), %rdi     # 0x23bf3
popq %rbx
jmp 0xd07c
movq 0x236d8(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1233a(%rip), %rsi     # 0x22c64
xorl %eax, %eax
callq 0x41c0
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: push_swstack
void
push_swstack(char *s)
{	char *nl;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movslq 0x2e599(%rip), %rax     # 0x3fd00
leal 0x1(%rax), %ecx
movl %ecx, 0x2e590(%rip)     # 0x3fd00
leaq 0x2e389(%rip), %rcx     # 0x3fb00
movq %r14, (%rcx,%rax,8)
andl $0x0, 0x2f9ae(%rip)     # 0x41130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: use_swstack
void
use_swstack(void)
{
	if (sw_level < 0 || sw_level > MAXLEVEL)
	{	fprintf(stderr, "swlevel error\n");
		exit(1);
	}
	vis_print(SwLabel[sw_level-1]);
	sw_first++;
}

// Assembly:
pushq %rax
movslq 0x2e56e(%rip), %rax     # 0x3fd00
cmpq $0x41, %rax
jae 0x117b1
leaq 0x2e361(%rip), %rcx     # 0x3fb00
movq -0x8(%rcx,%rax,8), %rdi
callq 0x106f2
incl 0x2f981(%rip)           # 0x41130
popq %rax
retq
movq 0x22840(%rip), %rax     # 0x33ff8
movq (%rax), %rcx
leaq 0x114ba(%rip), %rdi     # 0x22c7c
pushq $0xe
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/xtract.c
// Function: fputs_metachr
void
fputs_metachr(char c, int in_str)
{	char cstr[2];
	
	if (visu)
	switch (c) {
	case '\'': if (in_str) vis_print("'"); else vis_print("\\'"); break;
	case '"':  if (in_str) vis_print("\\\""); else vis_print("\""); break;
	case '\0': vis_print("\\0"); break;
	case '\\': vis_print("\\\\"); break;
	case '\n': vis_print("\\n"); break;
	case '\t': vis_print("\\t"); break;
	case '\r': vis_print("\\r"); break;
	case '\f': vis_print("\\f"); break;
	case '\b': vis_print("\\b"); break;
	case '\v': vis_print("\\v"); break;
	case '\a': vis_print("\\a"); break;
	default:   cstr[0] = c;
		   cstr[1] = '\0';
		   vis_print(cstr);
		   break;
	}
}

// Assembly:
leaq 0x251eb(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0x1185b
movsbl %dil, %eax
cmpl $0xd, %eax
ja 0x11817
leaq 0x10636(%rip), %rcx     # 0x21e38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1147f(%rip), %rdi     # 0x22c91
jmp 0x106f2
cmpl $0x22, %eax
je 0x118b0
cmpl $0x5c, %eax
je 0x118c0
cmpl $0x27, %eax
jne 0x11842
testl %esi, %esi
je 0x118cc
leaq 0x15b99(%rip), %rdi     # 0x273d6
jmp 0x106f2
pushq %rax
leaq 0x6(%rsp), %rax
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
movq %rax, %rdi
callq 0x106f2
addq $0x8, %rsp
retq
leaq 0xe960(%rip), %rdi      # 0x201c3
jmp 0x106f2
leaq 0x11437(%rip), %rdi     # 0x22ca6
jmp 0x106f2
leaq 0x1141f(%rip), %rdi     # 0x22c9a
jmp 0x106f2
leaq 0x1141c(%rip), %rdi     # 0x22ca3
jmp 0x106f2
leaq 0x1140d(%rip), %rdi     # 0x22ca0
jmp 0x106f2
leaq 0x113f8(%rip), %rdi     # 0x22c97
jmp 0x106f2
leaq 0x113f2(%rip), %rdi     # 0x22c9d
jmp 0x106f2
testl %esi, %esi
je 0x118d8
leaq 0x113d3(%rip), %rdi     # 0x22c8e
jmp 0x106f2
leaq 0x113cd(%rip), %rdi     # 0x22c94
jmp 0x106f2
leaq 0x113b8(%rip), %rdi     # 0x22c8b
jmp 0x106f2
leaq 0x1a306(%rip), %rdi     # 0x2bbe5
jmp 0x106f2
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: fputs_metastr
void
fputs_metastr(char *str)
{
	if (!visu) return;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x250ea(%rip), %rax     # 0x369d8
cmpl $0x0, (%rax)
je 0x1190e
movq %rdi, %rbx
pushq $0x1
popq %rbp
movb (%rbx), %al
testb %al, %al
je 0x1190e
movsbl %al, %edi
movl %ebp, %esi
callq 0x117e6
incq %rbx
jmp 0x118f9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: doindent
void
doindent(int depth)
{	int i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x25158(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
jne 0x11932
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
testl %edi, %edi
cmovgl %edi, %ebp
movq 0x226b8(%rip), %r12     # 0x33ff8
leaq 0x11310(%rip), %rbx     # 0x22c57
pushq $0x2
popq %r14
pushq $0x1
popq %r15
subl $0x1, %ebp
jb 0x11929
movq (%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x42c0
jmp 0x1194f
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: saw_variable
void
saw_variable(int ln, int which)
{
if (0) fprintf(stderr, "XXX {%d} '%s' '%s'\n", which, dername, dertype);
	if (strlen(dername) == 0)
	{	strcpy(dername, Ldername);
	}
	if (strlen(dertype) == 0)
	{	strcpy(dertype, Ldertype);
	}

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

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x0, 0x27a6c(%rip)     # 0x393e0
jne 0x11989
leaq 0x27a63(%rip), %rdi     # 0x393e0
leaq 0x2f7bc(%rip), %rsi     # 0x41140
callq 0x40b0
cmpb $0x0, 0x2f9b0(%rip)     # 0x41340
jne 0x119a5
leaq 0x2f9a7(%rip), %rdi     # 0x41340
leaq 0x2fba0(%rip), %rsi     # 0x41540
callq 0x40b0
movb 0x27a2c(%rip), %bpl     # 0x393d8
leaq 0x2fd8d(%rip), %rdi     # 0x41740
leaq 0xe6fc(%rip), %rsi      # 0x200b6
pushq $0x7
popq %rdx
callq 0x4250
leaq 0x2f977(%rip), %rdi     # 0x41340
leaq 0x27a10(%rip), %rsi     # 0x393e0
testb %bpl, %bpl
je 0x119f1
testl %eax, %eax
je 0x11a0d
leaq 0x2fd80(%rip), %rdx     # 0x41760
pushq $0x1
popq %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc107
testl %eax, %eax
je 0x11a1d
leaq 0x2fd64(%rip), %rdx     # 0x41760
pushq $0x1
popq %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe70
pushq $0x1
popq %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xadb9
pushq $0x1
popq %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xac17
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: precomputable
static int
precomputable(treenode *n)
{	int lft, rgt;

	if (!n) return 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x11adf
movq %rdi, %r14
movl 0x18(%rdi), %edi
leal -0x175(%rdi), %eax
cmpl $0x2, %eax
jb 0x11adf
cmpl $0x102, %edi            # imm = 0x102
je 0x11adf
cmpl $0x160, %edi            # imm = 0x160
je 0x11abd
cmpl $0x15e, %edi            # imm = 0x15E
je 0x11aa3
cmpl $0x108, %edi            # imm = 0x108
jne 0x11aea
movl 0x30(%r14), %ebx
jmp 0x11adf
movq 0x30(%r14), %rdi
callq 0x11a5d
movl %eax, %ebp
movq 0x38(%r14), %rdi
callq 0x11a5d
movl %eax, %ebx
orl %ebp, %ebx
jmp 0x11ad5
movq 0x30(%r14), %rdi
callq 0x11a5d
movl %eax, %ebp
movq 0x38(%r14), %rdi
callq 0x11a5d
movl %eax, %ebx
andl %ebp, %ebx
testl %eax, %eax
cmovel %eax, %ebx
testl %ebp, %ebp
cmovel %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x22507(%rip), %rax     # 0x33ff8
movq (%rax), %r15
movq 0x8(%r14), %r12
movl 0x10(%r14), %ebp
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x13d8c
leaq 0x119c4(%rip), %rsi     # 0x234d0
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x41c0
jmp 0x11adf
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: derive_type
void
derive_type(char *s, treenode *n)
{
	strcpy(derscope, s);
	strcpy(dertype, "");
	strcpy(dername, "");
	dotree(n, 0, 1);	/* calls 'add_global' and 'add_local'
				 * to instantiate rewrite rules
				 */
	strcpy(derscope, s);
	strcpy(dertype, "");
	strcpy(dername, "");
	with_decorations = 1;	/* reproduce the full declarations */
	dotree(n, 0, 1);
	with_decorations = 0;	/* such as [] and '*' with initialization */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2fc0b(%rip), %r15     # 0x41740
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b0
xorl %r12d, %r12d
movb %r12b, 0x2f7f6(%rip)    # 0x41340
movb %r12b, 0x2788f(%rip)    # 0x393e0
pushq $0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xb2b4
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b0
movb %r12b, 0x2f7ce(%rip)    # 0x41340
movb %r12b, 0x27867(%rip)    # 0x393e0
movb $0x1, 0x27858(%rip)     # 0x393d8
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xb2b4
movb %r12b, 0x27845(%rip)    # 0x393d8
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: set_join_id
void
set_join_id(void)	// from first '(' til first ',' in OutBuf
{	char *s, *e;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andq $0x0, 0x311e0(%rip)     # 0x43180
leaq 0x253d9(%rip), %rdi     # 0x37380
pushq $0x28
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x11fd7
movq %rax, %r15
leaq 0x1(%rax), %rbx
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x4130
testq %rax, %rax
je 0x11fd7
movq %rax, %r14
subq %r15, %r14
cmpq $0x2, %r14
jge 0x11fdd
popq %rbx
popq %r14
popq %r15
retq
movl %r14d, %edi
callq 0x4739
movq %rax, 0x31194(%rip)     # 0x43180
decq %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: set_create_id
void
set_create_id(void)	// from the 1st '&(' to the 1st '),' in OutBuf
{	char *s, *e;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andq $0x0, 0x31172(%rip)     # 0x43180
leaq 0x2536b(%rip), %rdi     # 0x37380
pushq $0x26
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x12042
movq %rax, %rbx
leaq 0x1(%rax), %rdi
pushq $0x29
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x12042
movq %rax, %r14
subq %rbx, %r14
cmpq $0x2, %r14
jge 0x1204a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x4739
movq %rax, 0x31127(%rip)     # 0x43180
addq $0x2, %rbx
addq $-0x2, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: set_thread_id
void
set_thread_id(void)	// from the 2nd ',' to the third ',' in OutBuf
{	char *s, *e;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andq $0x0, 0x31105(%rip)     # 0x43188
leaq 0x252f6(%rip), %rdi     # 0x37380
pushq $0x2c
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x120f3
incq %rax
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x4130
testq %rax, %rax
je 0x120f3
movq %rax, %r14
incq %r14
pushq $0x3e
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
jne 0x120d0
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
je 0x120f3
movq %rax, %rbx
leaq 0x1(%rax), %r14
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
je 0x120f3
movq %rax, %rcx
subq %rbx, %rcx
cmpq $0x2, %rcx
jge 0x120f9
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x29, -0x1(%rax)
leaq -0x1(%rax), %r15
cmovneq %rax, %r15
subq %rbx, %r15
movl %r15d, %edi
callq 0x4739
movq %rax, 0x31071(%rip)     # 0x43188
decq %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: set_thread_arg
void
set_thread_arg(void)	// from the 3rd ',' to the closing ')' in OutBuf
{	char *s, *e;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andq $0x0, 0x31056(%rip)     # 0x43190
leaq 0x2523f(%rip), %rdi     # 0x37380
pushq $0x2c
popq %rsi
callq 0x4130
testq %rax, %rax
je 0x121b7
incq %rax
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x4130
testq %rax, %rax
je 0x121b7
incq %rax
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x4130
testq %rax, %rax
je 0x121b7
movq %rax, %r15
leaq 0x1(%rax), %rbx
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x4150
testq %rax, %rax
je 0x121b7
movq %rax, %r14
subq %r15, %r14
leal 0x1(%r14), %edi
callq 0x4739
movq %rax, 0x30fef(%rip)     # 0x43190
decq %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4090
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: remember
void
remember(char *s, char *t)
{	Map *m;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4739
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x30fbb(%rip), %rcx     # 0x43198
movq %rcx, 0x10(%rax)
movq %rax, 0x30fb0(%rip)     # 0x43198
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/xtract.c
// Function: look_map
char *
look_map(char *s)
{	Map *m;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30f9a(%rip), %r14     # 0x43198
movq (%r14), %r14
testq %r14, %r14
je 0x12227
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0x1221b
addq $0x10, %r14
jmp 0x121fe
movq 0x8(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x21dca(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x10c55(%rip), %rsi     # 0x22e8d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
leaq 0x10c81(%rip), %rax     # 0x22eca
jmp 0x1221f