LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movzbl (%rdi), %eax
cmpl $0x9, %eax
je 0xfddf
testl %eax, %eax
je 0xfddf
incq %rdi
jmp 0xfdc5
movb $0x0, (%rdi)
movb 0x1(%rdi), %al
incq %rdi
cmpb $0x9, %al
je 0xfdd6
movzbl %al, %eax
cmpl $0x20, %eax
je 0xfdd6
testl %eax, %eax
je 0xfdf4
callq 0xfdc1
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x7517
// File: /workspace/github_c_makefile_star2_O3/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 0x2ec8e(%rip), %r13     # 0x3eaa0
testq %r13, %r13
je 0xfe60
movq %rdi, %rbx
leaq 0x12295(%rip), %r14     # 0x220b6
leaq 0x14a3f(%rip), %r15     # 0x24867
cmpl $0x0, 0x10(%r13)
jne 0xfe57
movq 0x8(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0xfe57
movq (%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x41d0
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0xfe28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x41a0
testq %rax, %rax
je 0xff17
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 0xfed4
btq %rcx, %r13
jae 0xfed4
movb $0x0, (%rax)
decq %rax
jmp 0xfebd
movq %r15, %r12
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0xfee6
cmpl $0x9, %eax
jne 0xfeeb
incq %r12
jmp 0xfed7
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 0xfe8d
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x2d9f7(%rip), %rax     # 0x3eab8
testq %rax, %rax
je 0x110d0
orb $0x5, 0x14(%rax)
movq 0x20(%rax), %rax
jmp 0x110c1
leaq 0x27bd9(%rip), %r14     # 0x38cb0
movq (%r14), %rsi
testq %rsi, %rsi
je 0x110f2
leaq 0x14fab(%rip), %rdi     # 0x26091
callq 0xff28
movq $0x0, (%r14)
movl 0x2a298(%rip), %ebp     # 0x3b390
incl %ebp
movl %ebp, 0x2a290(%rip)     # 0x3b390
leaq 0x1399b(%rip), %rsi     # 0x24aa2
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0x1112c
leaq 0x14f77(%rip), %rdi     # 0x26091
leaq 0x13981(%rip), %rsi     # 0x24aa2
callq 0xff28
movl 0x2a264(%rip), %ebp     # 0x3b390
incl %ebp
movl %ebp, 0x2a25c(%rip)     # 0x3b390
leaq 0x14f56(%rip), %rdi     # 0x26091
leaq 0x1396c(%rip), %rsi     # 0x24aae
callq 0xff28
addl $-0x2, 0x2a242(%rip)    # 0x3b390
movq 0x2d963(%rip), %rax     # 0x3eab8
testq %rax, %rax
je 0x11179
movl $0x1, %ecx
movl 0x14(%rax), %edx
movl %edx, %esi
andl $-0x6, %esi
testb $0x5, %dl
cmovel %ecx, %esi
movl %esi, 0x14(%rax)
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x1115f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x111f6
movl $0x9, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0x1f, %r14d
jg 0x111f6
movl $0x9, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0x17, %r14d
jg 0x111f6
movl $0x9, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0xf, %r14d
jg 0x111f6
movl $0x9, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0x7, %r14d
jg 0x111f6
movl $0x9, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x2d6d9(%rip), %r12     # 0x3eab8
testq %r12, %r12
jne 0x1140b
leaq 0x24db5(%rip), %rax     # 0x361a0
movq (%rax), %rdx
leaq 0x1372c(%rip), %rsi     # 0x24b21
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
movq 0x2d6b2(%rip), %r12     # 0x3eab8
testq %r12, %r12
je 0x11464
leaq 0x24d96(%rip), %r13     # 0x361a8
leaq 0x13720(%rip), %r14     # 0x24b39
leaq 0x13720(%rip), %r15     # 0x24b40
xorl %eax, %eax
cmpl $0x0, 0x14(%r12)
jne 0x1145a
testl %eax, %eax
jne 0x1143f
movq (%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41d0
movl $0x1, %eax
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x11422
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x114f2
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x114f2
movl %esi, %ebx
leaq 0x275e4(%rip), %r12     # 0x38a7c
testb $0x2, (%r12)
je 0x114da
leaq 0x2c15a(%rip), %r15     # 0x3d600
leaq 0x136a5(%rip), %rsi     # 0x24b52
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x42a0
movq %r15, %rdi
callq 0xeab6
movq 0x20(%r14), %rdi
movq 0x24b04(%rip), %rax     # 0x35fd0
movq (%rax), %rdx
xorl %esi, %esi
callq 0x1e416
movq 0x20(%r14), %rdi
movq 0x24b17(%rip), %rax     # 0x35ff8
movq (%rax), %rdx
movl %ebx, %esi
callq 0x1e308
testb $0x2, (%r12)
jne 0x114fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1383f(%rip), %rdi     # 0x24d44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xeab6
// File: /workspace/github_c_makefile_star2_O3/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 0x27e49(%rip), %r15     # 0x39380
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 0x6321
movq %rax, %r12
addq %rbp, %r15
leaq 0x135f0(%rip), %rsi     # 0x24b5c
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_O3/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 0x115dc
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 0x135a9(%rip), %rsi     # 0x24b65
movq %rsp, %rbx
movq %rbx, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x42a0
movq %rbx, %rdi
callq 0xeab6
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x29dd0(%rip)     # 0x3b3b8
jne 0x11660
cmpl $0x0, 0x29dcb(%rip)     # 0x3b3bc
jne 0x11660
cmpl $0x0, 0x2d4d2(%rip)     # 0x3eacc
jne 0x11660
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1166f
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x11660
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x1162b
movq %r14, %rdi
callq 0x11591
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x11616
movq 0x20(%rbx), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x11649
movq %r14, %rdi
callq 0x11591
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x11634
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rbx
testq %rbx, %rbx
je 0x11660
movq %rbx, %rdi
callq 0x11591
movq 0x10(%rbx), %rbx
jmp 0x1164d
leaq 0x17f77(%rip), %rax     # 0x295de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x134ff(%rip), %rdi     # 0x24b75
callq 0xeab6
callq 0x4060
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %r14
movq 0x2cd75(%rip), %r12     # 0x3eab8
testq %r12, %r12
je 0x11d80
movq %rsi, %rbx
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x41c0
testl %eax, %eax
jne 0x11d76
movq %r15, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
cmpq %rax, %r15
je 0x11da6
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x11d4b
leaq 0x24419(%rip), %rax     # 0x361a0
movq (%rax), %rsi
leaq 0x13826(%rip), %rdi     # 0x255b7
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 0x6321
movq %rax, 0x8(%r12)
leaq 0x26cba(%rip), %rcx     # 0x38a7c
testb $0x2, (%rcx)
je 0x11ded
leaq 0x243d2(%rip), %rcx     # 0x361a0
movq (%rcx), %rsi
leaq 0x137c1(%rip), %rdi     # 0x25599
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_O3/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
movl $0x10, %edi
callq 0x6321
movq %rbx, (%rax)
movq 0x2feb5(%rip), %rcx     # 0x41d08
movq %rcx, 0x8(%rax)
movq %rax, 0x2feaa(%rip)     # 0x41d08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x2fea5(%rip), %rdi     # 0x41d10
leaq 0x2750e(%rip), %rbx     # 0x39380
movq %rbx, %rsi
callq 0x40b0
movb $0x0, 0x274ff(%rip)     # 0x39380
movq 0x2fe80(%rip), %r14     # 0x41d08
testq %r14, %r14
je 0x11edf
movq (%r14), %rdi
callq 0xaca3
cmpq $0x0, 0x8(%r14)
je 0x11eb9
movq %rbx, %rdi
callq 0x4110
movl $0x20262620, (%rax,%rbx) # imm = 0x20262620
movb $0x0, 0x4(%rax,%rbx)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x11e8d
cmpb $0x0, 0x274c0(%rip)     # 0x39380
je 0x11edf
cmpb $0x0, 0x2a717(%rip)     # 0x3c5e0
je 0x11edf
movq %rbx, %rdi
callq 0x4110
movl $0x20262620, (%rax,%rbx) # imm = 0x20262620
movb $0x0, 0x4(%rax,%rbx)
leaq 0x2749a(%rip), %rbx     # 0x39380
leaq 0x2a6f3(%rip), %rsi     # 0x3c5e0
movq %rbx, %rdi
callq 0x4290
leaq 0x2cbe4(%rip), %rdi     # 0x3eae0
movq %rbx, %rsi
callq 0x40b0
leaq 0x2fe05(%rip), %rsi     # 0x41d10
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O3/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 0x125be
leaq 0x264c8(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0x125be
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rsi
movq %rsp, %rbx
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0x4090
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4130
testq %rax, %rax
je 0x125a3
movq %rax, %r14
movq %rsp, %rbx
leaq 0x26e29(%rip), %r15     # 0x39380
movb $0x0, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4290
movq %r15, %rdi
callq 0x4110
movw $0x5c, (%rax,%r15)
movq %r15, %rdi
callq 0x4110
movw $0x6e, (%rax,%r15)
movb $0xa, (%r14)
movq %r14, %rbx
incq %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4130
movq %rax, %r14
testq %rax, %rax
jne 0x12557
leaq 0x26dd6(%rip), %rdi     # 0x39380
movq %rbx, %rsi
callq 0x4290
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26412(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0x12600
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
subl 0x30742(%rip), %ebp     # 0x42d1c
jle 0x125f4
incl %ebp
leaq 0x12772(%rip), %r14     # 0x24d57
movq %r14, %rdi
callq 0xeab6
decl %ebp
cmpl $0x1, %ebp
ja 0x125e5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xeab6
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x28d8b(%rip), %r15     # 0x3b398
testq %r15, %r15
je 0x12630
movl %esi, %ebx
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0x12636
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x12617
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1271d(%rip), %rsi     # 0x24d5a
movl %ebx, %edi
callq 0x125bf
movq 0x8(%r15), %rdi
callq 0xeab6
leaq 0x1369d(%rip), %rdi     # 0x25cf1
popq %rbx
popq %r14
popq %r15
jmp 0xeab6
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %edi
callq 0x6321
movq %rax, %r14
movl 0x306a8(%rip), %edx     # 0x42d20
leal 0x1(%rdx), %eax
movl %eax, 0x3069f(%rip)     # 0x42d20
leaq 0x126d7(%rip), %rsi     # 0x24d5f
movq %r14, %rdi
xorl %eax, %eax
callq 0x42a0
movslq 0x26cdf(%rip), %rax     # 0x39378
leaq 0x30690(%rip), %rcx     # 0x42d30
movq %rbx, (%rcx,%rax,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x26ccb(%rip)     # 0x39378
leaq 0x3087c(%rip), %rcx     # 0x42f30
movq %r14, (%rcx,%rax,8)
movq %r14, %rdi
callq 0xeab6
leaq 0x1ac99(%rip), %rdi     # 0x2d360
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeab6
// File: /workspace/github_c_makefile_star2_O3/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 %edi, %ebx
movl 0x26c9c(%rip), %edi     # 0x39378
leal -0x41(%rdi), %eax
cmpl $-0x41, %eax
ja 0x126f2
leaq 0x26351(%rip), %rax     # 0x38a3c
cmpl $0x0, (%rax)
je 0x1273e
popq %rbx
retq
decl %edi
leaq 0x30635(%rip), %rax     # 0x42d30
movq (%rax,%rdi,8), %rdi
testq %rdi, %rdi
je 0x1270b
movl %ebx, %esi
callq 0x12743
leaq 0x12664(%rip), %rsi     # 0x24d76
movl %ebx, %edi
callq 0x125bf
movslq 0x26c58(%rip), %rax     # 0x39378
leaq 0x30809(%rip), %rcx     # 0x42f30
movq -0x8(%rcx,%rax,8), %rdi
callq 0xeab6
leaq 0x135bb(%rip), %rdi     # 0x25cf3
popq %rbx
jmp 0xeab6
callq 0x4cc6
// File: /workspace/github_c_makefile_star2_O3/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 0x6321
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movslq 0x2eb3e(%rip), %rax     # 0x41d00
leal 0x1(%rax), %ecx
movl %ecx, 0x2eb35(%rip)     # 0x41d00
leaq 0x2e92e(%rip), %rcx     # 0x41b00
movq %r14, (%rcx,%rax,8)
movl $0x0, 0x2ff50(%rip)     # 0x43130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2eb10(%rip), %rax     # 0x41d00
cmpq $0x41, %rax
jae 0x1320f
leaq 0x2e903(%rip), %rcx     # 0x41b00
movq -0x8(%rcx,%rax,8), %rdi
callq 0x12500
incl 0x2ff23(%rip)           # 0x43130
popq %rax
retq
callq 0x4dca
// File: /workspace/github_c_makefile_star2_O3/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 0x257ac(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0x13319
movsbl %dil, %eax
cmpl $0x21, %eax
jg 0x13265
cmpl $0xd, %eax
ja 0x13300
movl %eax, %eax
leaq 0x10ce8(%rip), %rcx     # 0x23f38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x11b31(%rip), %rdi     # 0x24d91
jmp 0x12500
cmpl $0x22, %eax
je 0x132e4
cmpl $0x5c, %eax
je 0x132f4
cmpl $0x27, %eax
jne 0x13300
testl %esi, %esi
je 0x1331a
leaq 0x1623b(%rip), %rdi     # 0x294c6
jmp 0x12500
leaq 0xef2c(%rip), %rdi      # 0x221c3
jmp 0x12500
leaq 0x11afa(%rip), %rdi     # 0x24d9d
jmp 0x12500
leaq 0x11af1(%rip), %rdi     # 0x24da0
jmp 0x12500
leaq 0x11aeb(%rip), %rdi     # 0x24da6
jmp 0x12500
leaq 0x11ad0(%rip), %rdi     # 0x24d97
jmp 0x12500
leaq 0x11ac7(%rip), %rdi     # 0x24d9a
jmp 0x12500
leaq 0x11ac4(%rip), %rdi     # 0x24da3
jmp 0x12500
testl %esi, %esi
je 0x13326
leaq 0x11a9f(%rip), %rdi     # 0x24d8e
jmp 0x12500
leaq 0x11a99(%rip), %rdi     # 0x24d94
jmp 0x12500
pushq %rax
leaq 0x6(%rsp), %rax
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
movq %rax, %rdi
callq 0x12500
addq $0x8, %rsp
retq
leaq 0x11a6a(%rip), %rdi     # 0x24d8b
jmp 0x12500
leaq 0x1a998(%rip), %rdi     # 0x2dcc5
jmp 0x12500
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x2569e(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0x13361
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x13361
incq %rbx
movsbl %al, %edi
movl $0x1, %esi
callq 0x13225
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x1334b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %ebx
cmpb $0x0, 0x28051(%rip)     # 0x3b3e0
jne 0x133a4
leaq 0x28048(%rip), %rdi     # 0x3b3e0
leaq 0x2fda1(%rip), %rsi     # 0x43140
callq 0x40b0
cmpb $0x0, 0x2ff95(%rip)     # 0x43340
jne 0x133c0
leaq 0x2ff8c(%rip), %rdi     # 0x43340
leaq 0x30185(%rip), %rsi     # 0x43540
callq 0x40b0
movl $0x626f6c47, %ecx       # imm = 0x626F6C47
xorl 0x30375(%rip), %ecx     # 0x43740
movl $0x6c6162, %edx         # imm = 0x6C6162
xorl 0x3036d(%rip), %edx     # 0x43743
xorl %eax, %eax
orl %ecx, %edx
setne %al
cmpb $0x0, 0x27ff4(%rip)     # 0x3b3d8
je 0x1340d
leaq 0x2ff53(%rip), %rdi     # 0x43340
leaq 0x27fec(%rip), %rsi     # 0x3b3e0
testl %eax, %eax
je 0x13434
leaq 0x30361(%rip), %rdx     # 0x43760
movl $0x1, %ecx
movl %ebx, %r8d
popq %rbx
jmp 0xdbee
leaq 0x2ff2c(%rip), %rdi     # 0x43340
leaq 0x27fc5(%rip), %rsi     # 0x3b3e0
testl %eax, %eax
je 0x13441
leaq 0x3033a(%rip), %rdx     # 0x43760
movl $0x1, %ecx
movl %ebx, %r8d
popq %rbx
jmp 0xd95a
movl $0x1, %edx
movl %ebx, %ecx
popq %rbx
jmp 0xca69
movl $0x1, %edx
movl %ebx, %ecx
popq %rbx
jmp 0xc8be
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x13504
movq %rdi, %r14
movl 0x18(%rdi), %esi
cmpl $0x15f, %esi            # imm = 0x15F
jg 0x134c9
cmpl $0x102, %esi            # imm = 0x102
je 0x13504
cmpl $0x108, %esi            # imm = 0x108
je 0x13500
cmpl $0x15e, %esi            # imm = 0x15E
jne 0x1350b
movq 0x30(%r14), %rdi
callq 0x1347e
movl %eax, %ebp
movq 0x38(%r14), %rdi
callq 0x1347e
movl %eax, %ebx
orl %ebp, %ebx
jmp 0x134f4
leal -0x175(%rsi), %eax
cmpl $0x2, %eax
jb 0x13504
cmpl $0x160, %esi            # imm = 0x160
jne 0x1350b
movq 0x30(%r14), %rdi
callq 0x1347e
movl %eax, %ebp
movq 0x38(%r14), %rdi
callq 0x1347e
movl %eax, %ebx
andl %ebp, %ebx
testl %eax, %eax
cmovel %eax, %ebx
testl %ebp, %ebp
cmovel %ebp, %ebx
jmp 0x13504
movl 0x30(%r14), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x4e30
jmp 0x13504
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30217(%rip), %r15     # 0x43740
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b0
xorl %ebp, %ebp
movb %bpl, 0x2fe03(%rip)     # 0x43340
movb %bpl, 0x27e9c(%rip)     # 0x3b3e0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xcf43
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b0
movb %bpl, 0x2fddb(%rip)     # 0x43340
movb %bpl, 0x27e74(%rip)     # 0x3b3e0
movb $0x1, 0x27e65(%rip)     # 0x3b3d8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xcf43
movb %bpl, 0x27e4f(%rip)     # 0x3b3d8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x3182f(%rip) # 0x45180
leaq 0x25a28(%rip), %rdi     # 0x39380
movl $0x28, %esi
callq 0x4130
testq %rax, %rax
je 0x1398c
movq %rax, %r15
leaq 0x1(%rax), %rbx
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x1398c
movq %rax, %r14
subq %r15, %r14
cmpq $0x2, %r14
jge 0x13992
popq %rbx
popq %r14
popq %r15
retq
movl %r14d, %edi
callq 0x6321
movq %rax, 0x317df(%rip)     # 0x45180
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_O3/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
movq $0x0, 0x317ba(%rip) # 0x45180
leaq 0x259b3(%rip), %rdi     # 0x39380
movl $0x26, %esi
callq 0x4130
testq %rax, %rax
je 0x139fe
movq %rax, %rbx
leaq 0x1(%rax), %rdi
movl $0x29, %esi
callq 0x4130
testq %rax, %rax
je 0x139fe
movq %rax, %r14
subq %rbx, %r14
cmpq $0x2, %r14
jge 0x13a06
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x6321
movq %rax, 0x3176b(%rip)     # 0x45180
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_O3/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
movq $0x0, 0x31746(%rip) # 0x45188
leaq 0x25937(%rip), %rdi     # 0x39380
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13abc
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13abc
movq %rax, %r14
incq %r14
movq %r14, %rdi
movl $0x3e, %esi
callq 0x4130
testq %rax, %rax
jne 0x13a97
movq %r14, %rdi
movl $0x2e, %esi
callq 0x4130
testq %rax, %rax
je 0x13abc
movq %rax, %rbx
leaq 0x1(%rax), %r14
movq %r14, %rdi
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13abc
movq %rax, %rcx
subq %rbx, %rcx
cmpq $0x2, %rcx
jge 0x13ac2
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 0x6321
movq %rax, 0x316a8(%rip)     # 0x45188
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_O3/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
movq $0x0, 0x3168a(%rip) # 0x45190
leaq 0x25873(%rip), %rdi     # 0x39380
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13b8b
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13b8b
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x4130
testq %rax, %rax
je 0x13b8b
movq %rax, %r15
leaq 0x1(%rax), %rbx
movq %rbx, %rdi
movl $0x29, %esi
callq 0x4150
testq %rax, %rax
je 0x13b8b
movq %rax, %r14
subq %r15, %r14
leal 0x1(%r14), %edi
callq 0x6321
movq %rax, 0x3161b(%rip)     # 0x45190
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_O3/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
movl $0x18, %edi
callq 0x6321
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x315e5(%rip), %rcx     # 0x45198
movq %rcx, 0x10(%rax)
movq %rax, 0x315da(%rip)     # 0x45198
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x315c4(%rip), %r14     # 0x45198
testq %r14, %r14
je 0x13bfa
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0x13bee
movq 0x10(%r14), %r14
jmp 0x13bd4
movq 0x8(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x223f7(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x11382(%rip), %rsi     # 0x24f8d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
leaq 0x113ae(%rip), %rax     # 0x24fca
jmp 0x13bf2
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: x_frag
void
x_frag(treenode *root, FILE *fd)
{	FILE *ofp = fp;

	if (!root
	||  root->hdr.type == TN_FUNC_DEF
	||  root->hdr.type == TN_FOR)	/* was FOR_T */
		return;

	fp = fd;
	ByPass = 1;	/* bypass the lookup table */
	decl_cnt = 1;

	vis_start();
	modex_recur(root);

	if (root->hdr.line >= 0
	&&  strlen(OutBuf) > 0
	&&  (strstr(OutBuf, "enum ") || strstr(OutBuf, "struct ")))	/* reason? */
	{	cleanse(OutBuf);
		/* fprintf(stderr, "x_frag OutBuf=<%s> want=<%s>\n", OutBuf, want); */
		if (imported(OutBuf, want, 1))
		{	if (du_mode)	/* -defuse */
			{	char *yy, *y = OutBuf;
				while (*y == '*' || *y == ' ' || *y == '\t')
				{	y++;
				}
				if ((yy = strstr(y, "[]")) != NULL)
				{	*yy = '\0';
				}
				fprintf(fp, "int %s; /* Local to %s from symtab */\n",
					y, want);
			} else
			{	if (!strchr(OutBuf, '='))	// should prevent this
				fprintf(fp, "c_state \"%s\" \"Local %s\"\t/* from symtab */\n",
					OutBuf, want);
	}	}	}

	root->hdr.line = -root->hdr.line - 1;	/* mark visited */
	decl_cnt = 0;
	ByPass = 0;
	fp = ofp;
}

// Assembly:
testq %rdi, %rdi
je 0x13d87
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %eax
cmpl $0x1, %eax
je 0x13d7c
cmpl $0x1e, %eax
je 0x13d7c
movq 0x25722(%rip), %r15     # 0x39370
movq %rsi, 0x2571b(%rip)     # 0x39370
movb $0x1, 0x2f0b4(%rip)     # 0x42d10
movl $0x1, 0x2fcfa(%rip)     # 0x43960
movb $0x0, 0x25713(%rip)     # 0x39380
movq %rbx, %rdi
callq 0xaca3
cmpl $0x0, 0x10(%rbx)
js 0x13d61
cmpb $0x0, 0x256fa(%rip)     # 0x39380
je 0x13d61
leaq 0x256ed(%rip), %rdi     # 0x39380
leaq 0x11177(%rip), %rsi     # 0x24e11
callq 0x42d0
testq %rax, %rax
jne 0x13cc0
leaq 0x256d5(%rip), %rdi     # 0x39380
leaq 0x11165(%rip), %rsi     # 0x24e17
callq 0x42d0
testq %rax, %rax
je 0x13d61
leaq 0x256b9(%rip), %r14     # 0x39380
movq %r14, %rdi
callq 0xe25b
leaq 0x224d2(%rip), %r12     # 0x361a8
movq (%r12), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xe541
testl %eax, %eax
je 0x13d61
leaq 0x24d66(%rip), %rax     # 0x38a58
cmpl $0x0, (%rax)
je 0x13d4b
movabsq $0x40100000200, %rax    # imm = 0x40100000200
movzbl (%r14), %ecx
cmpq $0x2a, %rcx
ja 0x13d16
btq %rcx, %rax
jae 0x13d16
incq %r14
jmp 0x13d01
leaq 0xe402(%rip), %rsi      # 0x2211f
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
je 0x13d2d
movb $0x0, (%rax)
movq 0x2563c(%rip), %rdi     # 0x39370
movq (%r12), %rcx
leaq 0x11295(%rip), %rsi     # 0x24fd4
movq %r14, %rdx
xorl %eax, %eax
callq 0x41d0
jmp 0x13d61
leaq 0x2562e(%rip), %rdi     # 0x39380
movl $0x3d, %esi
callq 0x4130
testq %rax, %rax
je 0x13d88
notl 0x10(%rbx)
movl $0x0, 0x2fbf2(%rip)     # 0x43960
movb $0x0, 0x2ef9b(%rip)     # 0x42d10
movq %r15, 0x255f4(%rip)     # 0x39370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x255e1(%rip), %rdi     # 0x39370
movq (%r12), %rcx
leaq 0x11261(%rip), %rsi     # 0x24ffb
leaq 0x255df(%rip), %rdx     # 0x39380
jmp 0x13d42
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: modex_leaf
void
modex_leaf(leafnode *leaf, int tabs)
{
	if (leaf == NULL || !visu) return;

	/* normally not called */
	linenr = leaf->hdr.line;
	vis_indent(tabs, "");

	switch(leaf->hdr.type){
	case TN_IDENT:	/* modex_leaf */
		vis_print(nmestr(leaf->data.sval));
		break;
	case TN_TYPE:
		if (Verbose&2)
		{	vis_print("Type ");
			vis_print(toksym(leaf->hdr.tok,0));
			if (leaf->hdr.tok == TYPEDEF_NAME)
			{	vis_print(" ");
				vis_print(nmestr(leaf->data.sval));
		}	}
		break;
	case TN_INT:
		vis_print("Int ");
		vis_print_d(leaf->data.ival);
		vis_print("\n");
		break;
	case TN_REAL:
		vis_print("Real ");
		vis_print_g(leaf->data.dval);
		vis_print("\n");
		break;
	case TN_STRING:
		if (0)
		fprintf(stderr, "STRING (%s) at line %3d\n",
			leaf->data.str, leaf->hdr.line);
		vis_print("\"");
		fputs_metastr(leaf->data.str);
		vis_print("\"");
		break;
	case TN_ELLIPSIS:
		vis_print("Ellipsis\n");
		break;
	case TN_LABEL:
		vis_print("Label\n");
		break;
	default:
		fprintf(stderr, "%s: error: unknown leaf type %d\n", progname, leaf->hdr.type);
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13ec6
leaq 0x24c21(%rip), %rax     # 0x389d8
cmpl $0x0, (%rax)
je 0x13ec6
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movl %eax, 0x2ef48(%rip)     # 0x42d14
leaq 0x122be(%rip), %rax     # 0x26091
movl %esi, %edi
movq %rax, %rsi
callq 0x125bf
movl 0x1c(%rbx), %edi
leal -0x22(%rdi), %eax
cmpl $0xf, %eax
ja 0x13ec1
leaq 0x1018d(%rip), %rcx     # 0x23f80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1123e(%rip), %rdi     # 0x25041
jmp 0x13eb5
leaq 0x19eb6(%rip), %r14     # 0x2dcc5
movq %r14, %rdi
callq 0x12500
movq 0x30(%rbx), %rdi
callq 0x13332
movq %r14, %rdi
jmp 0x13eb5
leaq 0x24c4d(%rip), %rax     # 0x38a7c
testb $0x2, (%rax)
je 0x13ec6
leaq 0x111e7(%rip), %rdi     # 0x25026
callq 0x12500
movl 0x18(%rbx), %edi
xorl %esi, %esi
callq 0x15de4
movq %rax, %rdi
callq 0x12500
cmpl $0x105, 0x18(%rbx)      # imm = 0x105
jne 0x13ec6
leaq 0x10ef2(%rip), %rdi     # 0x24d58
callq 0x12500
movq 0x30(%rbx), %rdi
callq 0x61c4
movq %rax, %rdi
jmp 0x13eb5
leaq 0x111b1(%rip), %rdi     # 0x25031
callq 0x12500
movsd 0x30(%rbx), %xmm0
callq 0x124c6
jmp 0x13eae
leaq 0x1119f(%rip), %rdi     # 0x25037
jmp 0x13eb5
leaq 0x1118b(%rip), %rdi     # 0x2502c
callq 0x12500
movl 0x30(%rbx), %edi
callq 0x1248a
leaq 0x108b5(%rip), %rdi     # 0x2476a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12500
callq 0x4ecc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: modex_reset
void
modex_reset(void)
{
	if (Verbose_cmds)
	{	printf(" -- Modex Reset\n");
	}

	decl_cnt = in_call = in_args = is_label = 0;
	just_left_blk = enum_list_cnt = taboffset = 0;
	sawdefault = Down = 0;
	FreshLut = needreturn = sawreturn = 0;
	ByPass = PosElse = 0;
	extra_comment = owf = owt = owh = 0;
	debug = lastln = lastpb = pending = 0;
	ishidden = wasfalse = wastrue = waselse = nreturns = 0;
	linenr = do_level = sw_level = sw_first = 0;
	do_uniq = o_cnt = visu = 0;
	nblanks = with_decorations = 0;
	cache = comms = commstail = (Cache *) 0;
	fcts = maps = incls = (Fcts *) 0;
	prec = (PreC *) 0;
	decors = fdecors = (Decor *) 0;

	strcpy(fct_name, ":global:");
	strcpy(derscope, "");
	strcpy(dertype,  "");
	strcpy(dername,  "");
	strcpy(derproc,  "");
}

// Assembly:
pushq %rax
leaq 0x24903(%rip), %rax     # 0x38a1c
cmpl $0x0, (%rax)
je 0x1412a
leaq 0x121e2(%rip), %rdi     # 0x26307
callq 0x40d0
xorl %eax, %eax
movl %eax, 0x2728e(%rip)     # 0x3b3c0
movl %eax, 0x27284(%rip)     # 0x3b3bc
movl %eax, 0x2727a(%rip)     # 0x3b3b8
movl %eax, 0x2f81c(%rip)     # 0x43960
movl %eax, 0x2ebd2(%rip)     # 0x42d1c
movl %eax, 0x3105c(%rip)     # 0x451ac
movl %eax, 0x2723a(%rip)     # 0x3b390
movb %al, 0x2ebbc(%rip)      # 0x42d18
movl %eax, 0x31042(%rip)     # 0x451a4
movl %eax, 0x31040(%rip)     # 0x451a8
movb %al, 0x2a946(%rip)      # 0x3eab4
movb %al, 0x2b96c(%rip)      # 0x3fae0
movb %al, 0x2eb96(%rip)      # 0x42d10
movl %eax, 0x31030(%rip)     # 0x451b0
movl %eax, 0x3102e(%rip)     # 0x451b4
movb %al, 0x2a944(%rip)      # 0x3ead0
movl %eax, 0x31026(%rip)     # 0x451b8
movl %eax, 0x307dc(%rip)     # 0x44974
movl %eax, 0x307d2(%rip)     # 0x44970
movl %eax, 0x30ffc(%rip)     # 0x451a0
movl %eax, 0x2d94e(%rip)     # 0x41af8
movl %eax, 0x2d944(%rip)     # 0x41af4
movl %eax, 0x2d93a(%rip)     # 0x41af0
movl %eax, 0x2ef74(%rip)     # 0x43130
movl %eax, 0x2db3e(%rip)     # 0x41d00
movl %eax, 0x251b0(%rip)     # 0x39378
movl %eax, 0x2eb46(%rip)     # 0x42d14
leaq 0x24803(%rip), %rcx     # 0x389d8
movl %eax, (%rcx)
movl %eax, 0x2a8bb(%rip)     # 0x3ea98
movl %eax, 0x2eb3d(%rip)     # 0x42d20
movb %al, 0x271ef(%rip)      # 0x3b3d8
movl %eax, 0x2a8d9(%rip)     # 0x3eac8
movq %rax, 0x30fca(%rip)     # 0x451c0
movq %rax, 0x2a8c3(%rip)     # 0x3eac0
movq %rax, 0x2a8b4(%rip)     # 0x3eab8
movq %rax, 0x27195(%rip)     # 0x3b3a0
movq %rax, 0x27196(%rip)     # 0x3b3a8
movq %rax, 0x2717f(%rip)     # 0x3b398
movq %rax, 0x2dae8(%rip)     # 0x41d08
movq %rax, 0x27161(%rip)     # 0x3b388
movq %rax, 0x27152(%rip)     # 0x3b380
movb %al, 0x22164(%rip)      # 0x36398
movabsq $0x3a6c61626f6c673a, %rcx # imm = 0x3A6C61626F6C673A
movq %rcx, 0x2214b(%rip)     # 0x36390
movb %al, 0x2f4f5(%rip)      # 0x43740
movb %al, 0x2f0ef(%rip)      # 0x43340
movb %al, 0x27189(%rip)      # 0x3b3e0
movb %al, 0x2f503(%rip)      # 0x43760
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: alldone
void
alldone(void)
{
	if (fp)
	{
if (debug_io) fprintf(stderr, "close .. %p\n", fp);
		Fclose(fp);
fp = 0;
	}
}

// Assembly:
movq 0x2510a(%rip), %rdx     # 0x39370
testq %rdx, %rdx
je 0x1428f
pushq %rax
leaq 0x247a5(%rip), %rax     # 0x38a18
cmpl $0x0, (%rax)
jne 0x14290
movq %rdx, %rdi
callq 0x77d0
movq $0x0, 0x250e5(%rip) # 0x39370
addq $0x8, %rsp
retq
movq 0x21d61(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x10e22(%rip), %rsi     # 0x250c3
xorl %eax, %eax
callq 0x41d0
movq 0x250c1(%rip), %rdx     # 0x39370
jmp 0x14278
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: prop_debug
void
prop_debug(treenode *n, int level, char letter)
{	int i;

	if (!n) return;

	printf("%c: ", letter);

	for (i = 0; i < level; i++)
		printf("  ");

	printf("(%s) %s, %s",
		toksym(n->hdr.tok, 0),
		name_of_nodetype(n->hdr.which),
		name_of_node(n->hdr.type));

	if (n->hdr.type == TN_IDENT)
	{	printf("\t(%s)\n", ((leafnode *)n)->data.sval->str);
		return;
	}
	printf("\n");
	prop_debug(n->lnode, level+1, 'L');
	prop_debug(n->rnode, level+1, 'R');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x145f8
movl %esi, %ebp
movq %rdi, %rbx
movsbl %dl, %esi
leaq 0x107f0(%rip), %r15     # 0x24d57
leaq 0x10bd0(%rip), %r12     # 0x2513e
leaq 0x10bc4(%rip), %rdi     # 0x25139
xorl %eax, %eax
callq 0x4140
testl %ebp, %ebp
jle 0x14592
movl %ebp, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x4140
decl %r14d
jne 0x14583
movl 0x18(%rbx), %edi
xorl %esi, %esi
callq 0x15de4
movq %rax, %r13
movl (%rbx), %edi
callq 0x16482
movq %rax, %r14
movl 0x1c(%rbx), %edi
callq 0x16550
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4140
cmpl $0x2d, 0x1c(%rbx)
je 0x14607
movl $0xa, %edi
callq 0x4050
movq 0x30(%rbx), %rdi
incl %ebp
movl %ebp, %esi
movl $0x4c, %edx
callq 0x14544
movq 0x38(%rbx), %rbx
movl $0x52, %esi
testq %rbx, %rbx
jne 0x1456e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x10b34(%rip), %rdi     # 0x2514a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: cnt_commas
int
cnt_commas(treenode *n)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT)
		return 0;

	return cnt_commas(n->lnode)
	     + cnt_commas(n->rnode)
	     + (n->hdr.tok == COMMA);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x1466a
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2d, 0x1c(%rdi)
je 0x14664
movq 0x30(%rbx), %rdi
callq 0x1462b
movl %eax, %ebp
movq 0x38(%rbx), %rdi
callq 0x1462b
movl %eax, %ecx
addl %ebp, %ecx
xorl %eax, %eax
cmpl $0x14c, 0x18(%rbx)      # imm = 0x14C
sete %al
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_terms
void
ax_terms(Ax_Props *np, treenode *n)
{
	if (!n) return;

	if (n->hdr.tok == COMMA)
	{	ax_terms(np, n->lnode);
		ax_terms(np, n->rnode);
	} else
	{	int i;
		for (i = 0; i < 2; i++)
			if (!np->terms[i])
			{	strcpy(Rem3, OutBuf);
				strcpy(OutBuf, "");
				modex_recur(n);
				np->terms[i] = (char *) e_malloc(strlen(OutBuf)+1);
				strcpy(np->terms[i], OutBuf);
				strcpy(OutBuf, Rem3);
				return;
			}
		fprintf(stderr, "%s: Error, too many npterms\n", progname);
		exit(1);	/* cannot happen */
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x1469e
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x14c, 0x18(%r14)      # imm = 0x14C
jne 0x146a8
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x1466b
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x1467f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x10(%rbx)
je 0x146c1
movl $0x1, %r13d
cmpq $0x0, 0x18(%rbx)
je 0x146c4
callq 0x4f1e
xorl %r13d, %r13d
leaq 0x30d05(%rip), %r15     # 0x453d0
leaq 0x24cae(%rip), %r12     # 0x39380
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b0
movb $0x0, 0x24c9c(%rip)     # 0x39380
movq %r14, %rdi
callq 0xaca3
movq %r12, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x10(%rbx,%r13,8)
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
movq %r12, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_new_assert
void
ax_new_assert(const int t, treenode *n)
{	Ax_Props *np;

	if (Verbose&2) prop_debug(n, 0, 'T');

	if (t > 1 || t < 0 || !n || cnt_commas(n) != t)
	{	if (n) fprintf(stderr, "%s: error, %s:%d, assert_%s, ",
			progname, n->hdr.fnm, n->hdr.line, t?"r":"p");
		fprintf(stderr, " (saw %d commas)\n", cnt_commas(n));
		return;
	}

	np = (Ax_Props *) e_malloc(sizeof(Ax_Props));
	np->t = t;
	np->n = n;
	np->nr = ax_prop_nr;
	np->terms[0] = (char *) 0;
	np->terms[1] = (char *) 0;
	ax_terms(np, n);

	np->nxt = all_props;
	all_props = np;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2434c(%rip), %rax     # 0x38a7c
testb $0x2, (%rax)
je 0x14744
movq %rbx, %rdi
xorl %esi, %esi
movl $0x54, %edx
callq 0x14544
cmpl $0x1, %ebp
ja 0x147a1
testq %rbx, %rbx
je 0x147a1
movq %rbx, %rdi
callq 0x1462b
cmpl %ebp, %eax
jne 0x147a8
movl $0x28, %edi
callq 0x6321
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movl 0x31c5d(%rip), %eax     # 0x463d0
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1466b
movq 0x31c47(%rip), %rax     # 0x463d8
movq %rax, 0x20(%r14)
movq %r14, 0x31c3c(%rip)     # 0x463d8
popq %rbx
popq %r14
popq %rbp
retq
xorl %edx, %edx
testq %rbx, %rbx
je 0x147f0
movq 0x21849(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x219e7(%rip), %rax     # 0x361a0
movq (%rax), %rdx
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %r8d
testl %ebp, %ebp
leaq 0x12130(%rip), %rax     # 0x268fd
leaq 0x105c7(%rip), %r9      # 0x24d9b
cmoveq %rax, %r9
leaq 0x1098f(%rip), %rsi     # 0x2516e
xorl %eax, %eax
callq 0x41d0
movq %rbx, %rdi
callq 0x1462b
movl %eax, %edx
movq 0x21801(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x1098b(%rip), %rsi     # 0x2518c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x41d0