LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: scopetab_find
symentry_t*
scopetab_find(scopetab_t *that, str_t *nme)
{	symentry_t *ret = NULL, *oret = NULL;
	int j;
	extern int structfieldflag;

if (DBG) {	printf("scopetab_find %s -- hashtab: <%p> -- ", nme->str, that?that->htab:0);
		printf("scopetab: %p, level: %d  nsyms: %d  nchild: %d -- structfield: %s -- owner_t: %d\n",
			that, that?that->level:-1, that?that->nsyms:-1, that?that->nchild:-1,
			structfieldflag?"YES":"no",
			that?that->owner_t:-1);
	}

	if (that)
	{	if (that->visited)
			return NULL;
		that->visited = 1;	/* prevent circularity */

		if (that->htab)
		{	if (!structfieldflag
			||   (that->level >= 3
			&&    that->owner_t == TN_OBJ_DEF))	/* Struct/Union, must have owner_t before ref */
			{	ret = hashtab_lookup(that->htab, nme);
			}
		}

		if (!ret && structfieldflag)	/* gjh */
		for (j = 0; j < that->nchild; j++)
		{	ret = scopetab_find(that->children[j], nme);
			if (ret)
			{	ret->used = 1;	/* set for all matches, return last */
				oret = ret;
if (DBG)			printf("Candidate Match %s: %p - %s:%d nes: %s\n",
					nme->str, ret, ret->fn, ret->ln,
					ret->nes && ret->nes->owner ? ret->nes->owner : "no owner");
		}	}
		if (!ret && oret) ret = oret;

		if (!ret) ret = scopetab_find(that->parent,nme);	/* goes up one level */

		that->visited = 0;
	}
	if (ret && structfieldflag) ret->used = 1;

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6819
movq %rdi, %rbx
cmpl $0x0, 0x24(%rdi)
je 0x682e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movl $0x1, 0x24(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x4569d(%rip), %r12     # 0x4bee0
movl (%r12), %ebp
testq %rdi, %rdi
je 0x6866
testl %ebp, %ebp
je 0x685c
cmpl $0x3, 0x4(%rbx)
jl 0x6866
cmpl $0x18, 0x20(%rbx)
jne 0x6866
movq %r14, %rsi
callq 0x65c2
jmp 0x6868
xorl %eax, %eax
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x68b2
cmpl $0x0, 0x28(%rbx)
jle 0x68b0
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq %r14, %rsi
callq 0x6800
testq %rax, %rax
je 0x68a2
movb $0x1, 0x22(%rax)
movq %rax, %r15
incq %r13
movslq 0x28(%rbx), %rcx
cmpq %rcx, %r13
jl 0x6886
jmp 0x68b5
xorl %eax, %eax
xorl %r15d, %r15d
testq %r15, %r15
cmoveq %rax, %r15
testq %rax, %rax
cmovneq %rax, %r15
testq %r15, %r15
jne 0x68d7
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x6800
movq %rax, %r15
movl $0x0, 0x24(%rbx)
testq %r15, %r15
je 0x681c
cmpl $0x0, (%r12)
je 0x681c
movb $0x1, 0x22(%r15)
jmp 0x681c
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: scopetab_insert
symentry_t *
scopetab_insert(scopetab_t *that, symentry_t *entry)
{
#if DBG
	int i;
	printf("	Inserting '%s' at level %d -- owner %s (%d) -- nchild %d\n",
		entry->nme->str, that->level, that->owner, that->owner_t, that->nchild);
	printf("	scopetab: %u; ", that);
	for (i = 0; i < that->nchild; i++)
		printf("%u, ", that->children[i]);
	printf("\n");
	
#endif
	if (!that->htab)
	{	that->htab = new_hashtab();
		if (!that->htab)
			return 0;
	}

	return hashtab_insert(that->htab,entry);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
jne 0x693d
movq %rdi, %r14
movl $0x18, %edi
callq 0x6321
movq %rax, %r15
movl $0x11, (%rax)
movl $0x88, %edi
callq 0x6321
movq %rax, 0x8(%r15)
movl $0x0, 0x4(%r15)
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x661d
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: find_glob_symentry
symentry_t *
find_glob_symentry(scopetab_t *that, char *s)
{	int j;
	symentry_t *fnd = (symentry_t *) 0;

	if (that->htab
	&&  that->level <= 2)
 		fnd = find_hashtab(that->htab, s);

	if (!fnd)
	for (j = 0; j < that->nchild; j++)
	{	if ((fnd = find_glob_symentry(that->children[j], s)) != NULL)
		{	break;
	}	}

	return fnd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x69ad
cmpl $0x2, 0x4(%r15)
jg 0x69ad
movslq (%rax), %r12
testq %r12, %r12
jle 0x69ad
movq 0x8(%rax), %r13
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r14
testq %r14, %r14
je 0x69a5
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x699f
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0x69e3
movq 0x38(%r14), %r14
jmp 0x6981
incq %rbp
cmpq %r12, %rbp
jne 0x697c
movslq 0x28(%r15), %r12
testq %r12, %r12
jle 0x69db
movq 0x30(%r15), %r15
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq %rbx, %rsi
callq 0x694d
testq %rax, %rax
jne 0x69e0
incq %r13
cmpq %r13, %r12
jne 0x69c0
jmp 0x69e3
xorl %r14d, %r14d
jmp 0x69e3
movq %rax, %r14
movq %r14, %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/symtab.c
// Function: find_symbol
int
find_symbol(scopetab_t *st, symentry_t *se)
{	int i;
	hashtab_t *h;
	symentry_t *e;

	if (!st || !se) { printf("<%p,%p> ",st,se); return 0; }

	h = st->htab;

	if (h)
	for (i = 0; i < h->tsize; i++)
	for (e = h->tab[i]; e; e = e->next)
	{	if (e == se)
		{
same:			printf("%s:%d: (scopetab %p symentry %p)", se->fn, se->ln, st, se);

			if (se->container)
			{	printf("cont:<%s> ",
					x_stmnt(se->container));
			}

			if (Verbose&2)
			{	switch (st->level) {
				case  0: printf("Top"); break;
				case  1: printf("Global"); break;
				case  2: printf("File"); break;
				case  3: printf("Struct/FctParams"); break;
				default: printf("Block"); break;
				}
			}
			return 1;
		} else if (strcmp(e->nme->str, se->nme->str) == 0)
		{	if (1 || (Verbose&2))
			{	printf("<rogue match> ");
				goto same;
			}
			return 0;
	}	}

	if (find_symbol(st->parent, se))
		return 1;

	printf("\n===couldn't find it:===\n");
	visu = 1;
	show_scopetab(st, 0, stdout);
	visu = 0;
	printf("===\n\t");

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x6aca
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6a6f
movslq (%rax), %r15
testq %r15, %r15
jle 0x6a6f
movq 0x8(%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
testq %rbp, %rbp
je 0x6a67
cmpq %r14, %rbp
je 0x6aff
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x41c0
testl %eax, %eax
je 0x6af1
movq 0x38(%rbp), %rbp
jmp 0x6a36
incq %r13
cmpq %r15, %r13
jne 0x6a32
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x69f5
movl $0x1, %ebp
testl %eax, %eax
jne 0x6ae0
leaq 0x1b765(%rip), %rdi     # 0x221f0
callq 0x40d0
movl $0x1, 0x31f3e(%rip)     # 0x389d8
movq 0x2f52f(%rip), %rax     # 0x35fd0
movq (%rax), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6ba0
movl $0x0, 0x31f1e(%rip)     # 0x389d8
leaq 0x1b627(%rip), %rdi     # 0x220e8
xorl %eax, %eax
callq 0x4140
jmp 0x6ae0
leaq 0x1b5ac(%rip), %rdi     # 0x2207d
xorl %ebp, %ebp
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4140
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b5e1(%rip), %rdi     # 0x220d9
xorl %eax, %eax
callq 0x4140
movq 0x28(%r14), %rsi
movl 0x24(%r14), %edx
leaq 0x1b578(%rip), %rdi     # 0x22086
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x4140
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x6b3a
callq 0xac1c
leaq 0x1b577(%rip), %rdi     # 0x220a7
movq %rax, %rsi
xorl %eax, %eax
callq 0x4140
leaq 0x31f3b(%rip), %rax     # 0x38a7c
movl $0x1, %ebp
testb $0x2, (%rax)
je 0x6ae0
movl 0x4(%rbx), %eax
cmpq $0x3, %rax
ja 0x6b94
leaq 0x1b4ed(%rip), %rcx     # 0x22048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b547(%rip), %rdi     # 0x220b2
jmp 0x6ac1
leaq 0x1b546(%rip), %rdi     # 0x220bd
jmp 0x6ac1
leaq 0x1b53f(%rip), %rdi     # 0x220c2
jmp 0x6ac1
leaq 0x1b527(%rip), %rdi     # 0x220b6
jmp 0x6ac1
leaq 0x1b538(%rip), %rdi     # 0x220d3
jmp 0x6ac1
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: show_scopetab
static void
show_scopetab(scopetab_t *that, int tabs, FILE *fp)
{	int j;
#if DBG
	fprintf(fp, "scopetab %u, level: %d  nsyms: %d  nchild: %d\n",
		that, that->level, that->nsyms, that->nchild);
#endif

	if (that->htab)
	{	scopetab_t *z;
		char prepped[512];
#if 1
		prepped[0] = '\0';
#else
		switch (that->level) {
		case  0: strcpy(prepped, "scope level 0?"); break;
		case  1: strcpy(prepped, "Global scope:"); break;
		case  2: strcpy(prepped, "File scope:"); break;
		case  3: strcpy(prepped, "Struct/FctParams:"); break;
		default: strcpy(prepped, "Block:"); break;
		}
#endif
		for (z = that; z; z = z->parent)
			if (z->owner
			&&  strcmp(z->owner, "-") != 0)
			{	strcat(prepped, "\t");
				strcat(prepped, z->owner);
				switch (z->owner_t) {
				case TN_OBJ_DEF:  strcat(prepped, " [struct/union]"); break;
				case TN_FUNC_DEF: strcat(prepped, " [fct]"); break;
				case 0: strcat(prepped, " [global]"); break;
				default: strcat(prepped, " [block]"); break;
				}
				break;
			}
#if DBG
			else strcat(prepped, "-u-");
#endif
		dotabs(tabs, fp);
		fprintf(fp, "%s\n", prepped);
		show_hashtab(that->htab, tabs, fp);
		fprintf(fp, "\n");
	}

	for (j = 0; j < that->nchild; j++)
		show_scopetab(that->children[j], tabs+1, fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x6cc4
movb $0x0, (%rsp)
movq %r14, %r12
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x6bde
cmpb $0x2d, (%rax)
jne 0x6bed
cmpb $0x0, 0x1(%rax)
jne 0x6bed
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x6bc9
jmp 0x6c6d
movq %rsp, %r15
movq %r15, %rdi
callq 0x4110
movw $0x9, (%rsp,%rax)
movq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x4290
movl 0x20(%r12), %r12d
movq %r15, %rdi
callq 0x4110
addq %rsp, %rax
testl %r12d, %r12d
je 0x6c47
cmpl $0x1, %r12d
je 0x6c38
cmpl $0x18, %r12d
jne 0x6c5c
movups 0x1b593(%rip), %xmm0    # 0x221c6
movups %xmm0, (%rax)
jmp 0x6c6d
movl $0x5d7463, 0x3(%rax)    # imm = 0x5D7463
movl $0x63665b20, (%rax)     # imm = 0x63665B20
jmp 0x6c6d
movabsq $0x6c61626f6c675b20, %rcx # imm = 0x6C61626F6C675B20
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
jmp 0x6c6d
movabsq $0x5d6b636f6c625b20, %rcx # imm = 0x5D6B636F6C625B20
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
testl %ebp, %ebp
jle 0x6c95
leaq 0x1b541(%rip), %r15     # 0x221b9
movl %ebp, %r12d
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r12d
jne 0x6c7b
leaq 0x1d6e0(%rip), %rsi     # 0x2437c
movq %rsp, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
movq 0x8(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x665d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0x0, 0x28(%r14)
jle 0x6cee
incl %ebp
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6ba0
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x6cd0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: remove_struct
void
remove_struct(char *s)
{	char *p, *q, *x;
	int cnt, m = 0, n = strlen(s);

	p = strstr(s, "struct");

	if (p)	/* check if struct is unnamed */
	{	x = p + strlen("struct");
		while (*x == ' ' || *x == '\t')
		{	x++;
		}
		if (*x == '{')	/* unnamed */
		{	return;
	}	}

	cnt = 0;
	for (q = p; q-p < n; q++)
	{	switch (*q) {
		case '{': cnt++; m++; break;
		case '}': cnt--; break;
		default: break;
		}
		if (m > 0)
		{	*q = ' ';
			if (cnt == 0)
			{	break;
	}	}	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4110
movq %rax, %rbx
leaq 0x1b3da(%rip), %rsi     # 0x220ee
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
je 0x6d3c
leaq 0x6(%rax), %rcx
movzbl (%rcx), %edx
cmpl $0x9, %edx
je 0x6d32
cmpl $0x20, %edx
jne 0x6d37
incq %rcx
jmp 0x6d25
cmpl $0x7b, %edx
je 0x6d7c
movslq %ebx, %rcx
testq %rcx, %rcx
jle 0x6d7c
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movzbl (%rsi), %r8d
cmpl $0x7d, %r8d
je 0x6d61
cmpl $0x7b, %r8d
jne 0x6d63
incl %edi
incl %edx
jmp 0x6d63
decl %edi
testl %edx, %edx
jle 0x6d6e
movb $0x20, (%rsi)
testl %edi, %edi
je 0x6d7c
incq %rsi
movq %rsi, %r8
subq %rax, %r8
cmpq %rcx, %r8
jl 0x6d4b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: find_typedefs
void
find_typedefs(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	symentry_t *t;
	char *s;
	int j;

	if (that->htab)
	{	for (z = that; z; z = z->parent)
		for (j = 0; j < that->htab->tsize; j++)
		for (t = that->htab->tab[j]; t; t = t->next)
		{	if (t->kind == TYPEDEF_ENTRY
			&&  t->generated == 0)
			{	s = nx_stmnt(t->node);
				if (strstr(s, "struct"))
				{	t->generated = 1;
					remove_newlines(s);
					remove_struct(s);	/* if named, it will be declared separately below */
					fprintf(fp, "c_decl { %s } /* find_typedefs %p, %p */\n", s, z, t);
	}	}	}	}

	for (j = 0; j < that->nchild; j++)
		find_typedefs(that->children[j], fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
sete %cl
movq %rdi, (%rsp)
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x6e58
movl (%rax), %ecx
leaq 0x1b337(%rip), %r15     # 0x220ee
movq (%rsp), %r13
testl %ecx, %ecx
jle 0x6e4b
xorl %r12d, %r12d
movq 0x8(%rax), %rdx
movq (%rdx,%r12,8), %rbp
testq %rbp, %rbp
je 0x6e3c
cmpl $0x1, (%rbp)
jne 0x6e29
cmpb $0x0, 0x23(%rbp)
jne 0x6e29
movq 0x10(%rbp), %rdi
callq 0xc0aa
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
je 0x6e29
movb $0x1, 0x23(%rbp)
movq %r14, %rdi
callq 0x6e91
movq %r14, %rdi
callq 0x6cfe
movq %rbx, %rdi
leaq 0x1b2dc(%rip), %rsi     # 0x220f5
movq %r14, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x41d0
movq 0x38(%rbp), %rbp
testq %rbp, %rbp
jne 0x6dd3
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
incq %r12
movslq %ecx, %rdx
cmpq %rdx, %r12
jl 0x6dc6
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x6dbb
movq (%rsp), %r15
cmpl $0x0, 0x28(%r15)
jle 0x6e82
xorl %r14d, %r14d
movq 0x30(%r15), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x6d84
incq %r14
movslq 0x28(%r15), %rax
cmpq %rax, %r14
jl 0x6e66
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/symtab.c
// Function: remove_newlines
static void
remove_newlines(char *s)
{	char *u;
	for (;;)
	{	u = strstr(s, "\\n");
		if (u) { *u++ = ' '; *u = ' '; }
		else { break; }
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b324(%rip), %rsi     # 0x221c3
callq 0x42d0
testq %rax, %rax
je 0x6ec5
leaq 0x1b313(%rip), %r14     # 0x221c3
movw $0x2020, (%rax)         # imm = 0x2020
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
jne 0x6eb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: set_owner
void
set_owner(scopetab_t *p, char *s, int tp)
{	int i;

	if (0) printf("	setowner for %p %s %d (%s)\n", p, s, tp,
			p->owner?p->owner:"not yet set");

	if (p->owner) return;	/* already named */

	p->owner = s;
	p->owner_t = tp;

	for (i = 0; i < p->nchild; i++)		/* propagate to nested unnamed scopes */
		set_owner(p->children[i], s, tp);
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x70d5
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
cmpl $0x0, 0x28(%rdi)
jle 0x7113
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x70cd
incq %r12
movslq 0x28(%r15), %rax
cmpq %rax, %r12
jl 0x70f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (DBG) printf("name_scope %p -- owner=%s (owner_t=%d) clevel %d, level %d\n",
		p->current,
		s, tp,
		p->clevel,
		p->current->level);
	set_owner(p->current, s, tp);

	if (Verbose&2)
	printf("SET level %d,%d, %s\n",
		p->clevel,  p->current->level,  s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x10(%r14), %rdi
callq 0x70cd
leaq 0x31942(%rip), %rax     # 0x38a7c
testb $0x2, (%rax)
jne 0x7147
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x1b01b(%rip), %rdi     # 0x22174
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert
symentry_t*
symtab_insert(symtab_t *that, symentry_t *entry)
{	symentry_t *t;
#if DBG
	printf("	symtab insert %s (clevel %d currentlevel %d) %u\n",
		entry->nme->str, that->clevel, that->current->level, entry);
#endif
	while (that->clevel > that->current->level)
	{	scopetab_t *child = new_scopetab(that->current);

		if (!child || !child_insert(that->current,child))
			return NULL;

		that->current = child;
	}
	t = scopetab_insert(that->current,entry);
#if DBG
	printf("	inserted at %u\n", t);
#endif
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r14
cmpl 0x4(%r14), %eax
jle 0x7215
movq %rdi, %r15
movq %r14, %rdi
callq 0x67b3
testq %rax, %rax
je 0x7225
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rax, %rsi
callq 0x722d
movq %r14, 0x10(%r15)
movl 0x8(%r15), %eax
cmpl 0x4(%r14), %eax
jg 0x71eb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x68fc
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: child_insert
static int
child_insert(scopetab_t *mom, scopetab_t *kid)
{	int j;

	if (0)
	printf("		child insert - level %d\n", mom->level);

	if (mom->nchild >= mom->size)
	{	scopetab_t **oldkids = mom->children;
		mom->size += mom->size;
		mom->children = (scopetab_t **) e_malloc( sizeof(scopetab_t*) * mom->size );

		for (j=0; j < mom->nchild; j++)
			mom->children[j] = oldkids[j];
	}

	mom->children[mom->nchild] = kid;
	(mom->nchild)++;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %eax
movl 0x2c(%rdi), %edi
cmpl %edi, %eax
jl 0x7277
movq 0x30(%rbx), %r15
leal (%rdi,%rdi), %eax
movl %eax, 0x2c(%rbx)
shll $0x4, %edi
callq 0x6321
movq %rax, 0x30(%rbx)
movslq 0x28(%rbx), %rax
testq %rax, %rax
jle 0x7277
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq 0x30(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x7263
movq 0x30(%rbx), %rcx
cltq
movq %r14, (%rcx,%rax,8)
incl %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert_at
symentry_t *
symtab_insert_at(symtab_t *that, symentry_t *entry, int level)
{	scopetab_t *scp;
	scopetab_t *child;

#ifdef  MORE_VERBOSE
	printf("scope level %d; ",   that->current->level);
	printf("current level %d; ", that->clevel);
	printf("request level %d\n", level);
#endif

	while ((that->clevel >  that->current->level)
	    && (that->clevel >= level))
	{
		child = new_scopetab(that->current);

		if (!child
		||  !child_insert(that->current,child))
			return (symentry_t *) 0;

		that->current = child;
	}

	scp = that->current;

	while (scp && (scp->level > level))
		scp = scp->parent;

	if (scp)
		return scopetab_insert(scp,entry);

	return (symentry_t *) 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r14
cmpl %edx, %eax
jl 0x72e5
cmpl 0x4(%r14), %eax
jle 0x72e5
movq %rdi, %r15
movq %r14, %rdi
callq 0x67b3
testq %rax, %rax
je 0x7300
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rax, %rsi
callq 0x722d
movq %r14, 0x10(%r15)
movl 0x8(%r15), %eax
cmpl %ebp, %eax
jl 0x72e5
cmpl 0x4(%r14), %eax
jg 0x72ac
jmp 0x72e5
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x7300
cmpl %ebp, 0x4(%r14)
jg 0x72dc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x68fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: add_fctnm
void
add_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return;
	}	}
	f = (NameList *) e_malloc(sizeof(NameList));
	f->nm = s;
	f->nxt = fctnms;
	fctnms = f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3168a(%rip), %r14     # 0x389e0
testq %r14, %r14
je 0x7370
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x41c0
testl %eax, %eax
je 0x738f
movq 0x8(%r14), %r14
jmp 0x7356
movl $0x10, %edi
callq 0x6321
movq %rbx, (%rax)
movq 0x3165c(%rip), %rcx     # 0x389e0
movq %rcx, 0x8(%rax)
movq %rax, 0x31651(%rip)     # 0x389e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: is_fctnm
int
is_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return 1;
	}	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x3163d(%rip), %r15     # 0x389e0
xorl %ebx, %ebx
testq %r15, %r15
je 0x73cc
movq %rdi, %r14
movq (%r15), %rdi
movq %r14, %rsi
callq 0x41c0
testl %eax, %eax
je 0x73c7
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x73ad
jmp 0x73cc
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: save_fcts
void
save_fcts(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	int j;

	for (z = that; z; z = z->parent)
	{	if (z->owner
		&&  z->owner_t == TN_FUNC_DEF
		&&  strcmp(z->owner, "-") != 0)
		{	add_fctnm(z->owner);
	}	}

	for (j = 0; j < that->nchild; j++)
		save_fcts(that->children[j], fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x7410
movq %r14, %r15
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x7407
cmpl $0x1, 0x20(%r15)
jne 0x7407
cmpb $0x2d, (%rdi)
jne 0x7402
cmpb $0x0, 0x1(%rdi)
je 0x7407
callq 0x7348
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x73e7
cmpl $0x0, 0x28(%r14)
jle 0x7436
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x73d4
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x741a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) e_malloc( sizeof(context_t) );

	that->labels = new_symtab();
	that->tags   = new_symtab();
	that->syms   = new_symtab();

	return that;
}

// Assembly:
pushq %rbx
movl $0x18, %edi
callq 0x6321
movq %rax, %rbx
callq 0x716a
movq %rax, (%rbx)
callq 0x716a
movq %rax, 0x8(%rbx)
callq 0x716a
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: exit_scope
void
exit_scope(context_t *that)
{
#ifdef  MORE_VERBOSE
	printf("	Exit Scope: %d\n", that->syms->clevel);
#endif
	st_exit_scope(that->labels);
	st_exit_scope(that->tags);
	st_exit_scope(that->syms);
}

// Assembly:
movq (%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x74a0
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x74be
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x74dc
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: exit_scopes
void
exit_scopes(context_t *that, int newlev)
{
	if (newlev < EXTERN_SCOPE)
		newlev = EXTERN_SCOPE;

	while (newlev < that->syms->current->level)
		exit_scope(that);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %esi
movl $0x1, %ebp
cmovgel %esi, %ebp
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
cmpl 0x4(%rax), %ebp
jge 0x7510
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x7483
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
cmpl 0x4(%rax), %ebp
jl 0x74fb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: add_constant
void
add_constant(char *p, int isvis)
{	Cname *s;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x314c0(%rip), %r15     # 0x389e8
testq %r15, %r15
je 0x7542
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41c0
testl %eax, %eax
je 0x758b
movq 0x18(%r15), %r15
jmp 0x7528
movl $0x20, %edi
callq 0x6321
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movl $0x0, 0x8(%r15)
movl %ebx, 0xc(%r15)
movq 0x31468(%rip), %rax     # 0x389e8
movq %rax, 0x18(%r15)
movq %r15, 0x3145d(%rip)     # 0x389e8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: is_constant
int
is_constant(char *p)
{	Cname *s;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x3144b(%rip), %r15     # 0x389e8
xorl %ebx, %ebx
testq %r15, %r15
je 0x75ce
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41c0
testl %eax, %eax
je 0x75c1
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x75a7
jmp 0x75ce
movl $0x1, 0x8(%r15)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: do_constants
void
do_constants(FILE *fd)
{	Cname *s;
	int i = 1;

	if (!cnames) return;

	fprintf(fd, "\n");
	for (s = cnames; s; s = s->nxt)
	{	if (s->purged)
		{	continue;
		}
		s->purged = 1;
		if (s->isvis)
		{	fprintf(fd, "hidden int %s = %d;\n", s->vn, i++);
	}	}
	fprintf(fd, "\n");
}

// Assembly:
cmpq $0x0, 0x3140a(%rip)     # 0x389e8
je 0x765a
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4190
movq 0x313ea(%rip), %r15     # 0x389e8
testq %r15, %r15
je 0x7643
movl $0x1, %ecx
leaq 0x1ab7a(%rip), %r14     # 0x22189
cmpl $0x0, 0x10(%r15)
jne 0x763a
movl $0x1, 0x10(%r15)
cmpl $0x0, 0xc(%r15)
je 0x763a
movq (%r15), %rdx
leal 0x1(%rcx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movl %ebp, %ecx
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x760f
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4190
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: add_icall
void
add_icall(char *p)
{	Cname *s;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x31387(%rip), %r14     # 0x389f0
testq %r14, %r14
je 0x7683
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0x76c8
movq 0x18(%r14), %r14
jmp 0x7669
movl $0x20, %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x8(%r14)
movq 0x31333(%rip), %rax     # 0x389f0
movq %rax, 0x18(%r14)
movq %r14, 0x31328(%rip)     # 0x389f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: is_icall
int
is_icall(char *p)
{	Cname *s;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x312d5(%rip), %r14     # 0x389f8
testq %r14, %r14
je 0x773d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0x7782
movq 0x18(%r14), %r14
jmp 0x7723
movl $0x20, %edi
callq 0x6321
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x8(%r14)
movq 0x31281(%rip), %rax     # 0x389f8
movq %rax, 0x18(%r14)
movq %r14, 0x31276(%rip)     # 0x389f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/symtab.c
// Function: is_pname
int
is_pname(char *p)
{	Cname *s;

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7f3b
movl %edx, %ebx
movq %rsi, %r14
movsbl %dil, %ebp
cmpl $0x70, %ebp
je 0x7e9c
cmpl $0x65, %ebp
jne 0x7ea4
movq %r14, %rdi
callq 0x765b
jmp 0x7ea4
movq %r14, %rdi
callq 0x7715
movl $0x18, %edi
callq 0x6321
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, (%rax)
movl 0x2e340(%rip), %eax     # 0x36200
movl %eax, 0x4(%r15)
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
cmpl $0x0, 0x30b32(%rip)     # 0x38a1c
je 0x7f08
movl 0x2e30d(%rip), %r8d     # 0x36200
leaq 0x1b29f(%rip), %rdi     # 0x23199
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x4140
movq 0x30b11(%rip), %rax     # 0x38a20
testq %rax, %rax
je 0x7f18
movq %r15, 0x10(%rax)
movq %r15, 0x30b01(%rip)     # 0x38a20
cmpq $0x0, 0x30b01(%rip)     # 0x38a28
jne 0x7f30
movq %r15, 0x30af8(%rip)     # 0x38a28
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %dil, %edi
callq 0x432b
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: expand_cmd
void
expand_cmd(char c, char *s, int h)	// e.g., s="one,two,three"
{	char *z = s;

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

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x20a13(%rip), %rsi     # 0x298df
callq 0x4270
movq %rax, 0x2fdf8(%rip)     # 0x38cd0
testq %rax, %rax
je 0x8f16
cmpl $0x0, 0x2fb34(%rip)     # 0x38a18
jne 0x8ef6
movq %rbx, %rdi
callq 0xe5e3
incl 0x2fde4(%rip)           # 0x38cd8
popq %rbx
retq
movq 0x2d0fb(%rip), %rcx     # 0x35ff8
movq (%rcx), %rdi
leaq 0x1a3e2(%rip), %rsi     # 0x232e9
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x41d0
jmp 0x8ee6
movq %rbx, %rdi
callq 0x4385
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: header
void
header(char *bnm, char *suffix1)
{	char *fnm;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2fda0(%rip), %rcx     # 0x38cd0
testq %rcx, %rcx
je 0x8f82
cmpb $0x1, 0x2fda0(%rip)     # 0x38cdc
jne 0x8f64
testb $0x1, 0x2fd9b(%rip)     # 0x38ce0
jne 0x8f64
leaq 0x1cd51(%rip), %rdi     # 0x25c9f
movl $0x2, %esi
movl $0x1, %edx
callq 0x42c0
movq 0x2fd6c(%rip), %rcx     # 0x38cd0
cmpq 0x2fd7d(%rip), %rcx     # 0x38ce8
je 0x8f82
cmpl $0x0, 0x2faa4(%rip)     # 0x38a18
jne 0x9054
movq %rcx, %rdi
callq 0x77d0
xorl %eax, %eax
movb %al, 0x2fd56(%rip)      # 0x38ce0
movb %al, 0x2fd60(%rip)      # 0x38cf0
movb %al, 0x2fd5e(%rip)      # 0x38cf4
movb %al, 0x2fd5c(%rip)      # 0x38cf8
movb %al, 0x2fd3a(%rip)      # 0x38cdc
movb %al, 0x2fd54(%rip)      # 0x38cfc
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x6321
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4290
leaq 0x1a31e(%rip), %rsi     # 0x23304
movq %rbx, %rdi
callq 0x41c0
testl %eax, %eax
je 0x8fff
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8ec1
cmpb $0x0, 0x2fcfa(%rip)     # 0x38d00
je 0x901c
movq 0x2fcd9(%rip), %rax     # 0x38ce8
movq %rax, 0x2fcba(%rip)     # 0x38cd0
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x8ec1
movq 0x2fca5(%rip), %rcx     # 0x38cd0
movq %rcx, 0x2fcb6(%rip)     # 0x38ce8
movb $0x1, 0x2fcc7(%rip)     # 0x38d00
leaq 0x1a2c9(%rip), %rdi     # 0x23309
movl $0x15, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x42c0
movq 0x2cf9d(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x1a293(%rip), %rsi     # 0x232f8
movq %rcx, %rdx
xorl %eax, %eax
callq 0x41d0
movq 0x2fc5a(%rip), %rcx     # 0x38cd0
jmp 0x8f7a
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: Arg_Add
void
Arg_Add(char *s, char *t)
{
	if (strlen(s) == 0) return;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, (%rdi)
je 0x9130
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2f983(%rip)     # 0x38a1c
je 0x90af
leaq 0x1a27d(%rip), %rdi     # 0x2331f
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4140
cmpl $0x80, 0x2d15f(%rip)    # 0x36218
jge 0x9139
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
callq 0x4110
leal (%rax,%r15), %edi
incl %edi
callq 0x6321
movl 0x2d139(%rip), %ebp     # 0x36218
movslq %ebp, %r15
leaq 0x2fc27(%rip), %r12     # 0x38d10
movq %rax, (%r12,%r15,8)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movq (%r12,%r15,8), %rdi
movq %rbx, %rsi
callq 0x4290
cmpl $0x0, 0x2f911(%rip)     # 0x38a1c
je 0x9128
movq (%r12,%r15,8), %rdx
leaq 0x1a231(%rip), %rdi     # 0x23349
movl %r15d, %esi
xorl %eax, %eax
callq 0x4140
movl 0x2d0f0(%rip), %ebp     # 0x36218
incl %ebp
movl %ebp, 0x2d0e8(%rip)     # 0x36218
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x43a9
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: Add_Args
void
Add_Args(char *s)
{	char *t, *v;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x2f8d0(%rip)     # 0x38a1c
je 0x915f
leaq 0x1a203(%rip), %rdi     # 0x23358
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4140
leaq 0x1cf2b(%rip), %r14     # 0x26091
movq %rbx, %rdi
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0x917c
cmpl $0x20, %eax
je 0x917c
testl %eax, %eax
jne 0x919a
jmp 0x919f
movb $0x0, (%rbx)
movq %r14, %rsi
callq 0x907b
incq %rbx
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x9187
cmpl $0x9, %eax
je 0x9187
movq %rbx, %rdi
incq %rbx
jmp 0x9169
leaq 0x1ceeb(%rip), %rsi     # 0x26091
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x907b
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: boiler_plate
void
boiler_plate(FILE *fd, int pre)
{
	fprintf(fd, "\t\tif [ -f _modex_.drv ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"error: no ./_modex_.drv file\"\n");
	fprintf(fd, "\t\t	exit 1\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\t%s model pan.? pan pan.exe _spin_nvr.tmp\n\n", RM);
	fprintf(fd, "\t\tif [ -f _modex_.h ]\n");
	fprintf(fd, "\t\tthen	true\n");
	fprintf(fd, "\t\telse	echo \"\" > _modex_.h\n");
	fprintf(fd, "\t\tfi\n\n");
	fprintf(fd, "\t\techo \"// Generated by %s\" > model\n", VERSION);
	fprintf(fd, "\t\techo \"// `date` from %s\" >> model\n", file_name);
	fprintf(fd, "\t\techo \"\" >> model\n");
	fprintf(fd, "\t\tif [ -f _modex_.b4g ]\n");
	fprintf(fd, "\t\tthen	cat _modex_.b4g >> model\n");
	fprintf(fd, "\t\tfi\n");
	fprintf(fd, "\t\t%s _modex_.drv | grep -v -e '^$' -e '^# ' >> model", CPP);
	if (pre)
	{	fprintf(fd, " 2>&1");
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1a1df(%rip), %rdi     # 0x233d2
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1df(%rip), %r14     # 0x233eb
movl $0xc, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1d0(%rip), %rdi     # 0x233f8
movl $0x2b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1e3(%rip), %rdi     # 0x23424
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1d5(%rip), %r15     # 0x2342f
movl $0x6, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1c0(%rip), %rsi     # 0x23436
leaq 0x1a1e6(%rip), %rdx     # 0x23463
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
leaq 0x1a1db(%rip), %rdi     # 0x23469
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl $0xc, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1c4(%rip), %rdi     # 0x23480
movl $0x1b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl $0x6, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42c0
movq 0x2cea6(%rip), %rdx     # 0x36190
leaq 0x1a1ab(%rip), %rsi     # 0x2349c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
movq 0x2f786(%rip), %rdx     # 0x38a88
leaq 0x1a1b8(%rip), %rsi     # 0x234c1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
leaq 0x1a1cc(%rip), %rdi     # 0x234e6
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1c7(%rip), %rdi     # 0x234fa
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1c7(%rip), %rdi     # 0x23513
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1cf(%rip), %rdi     # 0x23534
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1a1bc(%rip), %rsi     # 0x2353a
leaq 0x1a1ea(%rip), %rdx     # 0x2356f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
testl %ebp, %ebp
je 0x93ac
leaq 0x1a1e1(%rip), %rdi     # 0x2357b
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4190
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: add_to_file
void
add_to_file(char *buf)
{	char *z;
	int i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2efed(%rip), %r14     # 0x38cd0
testq %r14, %r14
je 0x9d0d
movb 0x2f00a(%rip), %al      # 0x38cf8
cmpb $0x0, 0x2f007(%rip)     # 0x38cfc
jne 0x9d73
testb $0x1, 0x2efde(%rip)     # 0x38cdc
jne 0x9d73
testb $0x1, %al
jne 0x9d73
testb $0x1, 0x2efe9(%rip)     # 0x38cf4
jne 0x9d73
movq 0x2c50c(%rip), %r14     # 0x36220
testq %r14, %r14
setne %al
andb 0x2efd0(%rip), %al      # 0x38cf0
cmpb $0x1, %al
jne 0x9d67
leaq 0x2c505(%rip), %r12     # 0x36230
movq %r14, %rdi
callq 0x4110
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40a0
testl %eax, %eax
jne 0x9d5a
addq %rbx, %r15
movq %r15, %rdi
callq 0x4280
movq -0x8(%r12), %rcx
movl %eax, (%rcx)
movq (%r12), %r14
addq $0x10, %r12
testq %r14, %r14
jne 0x9d2b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %al
je 0x9d8e
leaq 0x19b1c(%rip), %rsi     # 0x2389a
movq %rbx, %rdi
callq 0x42d0
testq %rax, %rax
je 0x9d8e
movb $0xa, (%rax)
leaq 0x1a5e7(%rip), %rsi     # 0x2437c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: close_file
void
close_file(void)
{
	if (incode && !inltl)  fprintf(fo, "}\n");
	if (fo && fo != fdrv)
	{
if (debug_io) fprintf(stderr, "close 5 %p\n", fo);
		Fclose(fo);
	}
	fo = NULL;
	inlut = incode = inspn = inltl = 0;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x2ef27(%rip)     # 0x38cdc
jne 0x9ddd
testb $0x1, 0x2ef22(%rip)     # 0x38ce0
jne 0x9ddd
movq 0x2ef09(%rip), %rcx     # 0x38cd0
leaq 0x1bed1(%rip), %rdi     # 0x25c9f
movl $0x2, %esi
movl $0x1, %edx
callq 0x42c0
movq 0x2eeec(%rip), %rdx     # 0x38cd0
testq %rdx, %rdx
je 0x9e03
cmpq 0x2eef8(%rip), %rdx     # 0x38ce8
je 0x9e03
cmpl $0x0, 0x2ec1f(%rip)     # 0x38a18
jne 0x9e2a
movq %rdx, %rdi
callq 0x77d0
movq $0x0, 0x2eec2(%rip) # 0x38cd0
xorl %eax, %eax
movb %al, 0x2eeca(%rip)      # 0x38ce0
movb %al, 0x2eedc(%rip)      # 0x38cf8
movb %al, 0x2eeba(%rip)      # 0x38cdc
movb %al, 0x2eed4(%rip)      # 0x38cfc
popq %rax
retq
movq 0x2c1c7(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x19a62(%rip), %rsi     # 0x2389d
xorl %eax, %eax
callq 0x41d0
movq 0x2ee87(%rip), %rdx     # 0x38cd0
jmp 0x9dfb
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: check_param
void
check_param(char *cmd)		/* check for filename param */
{	FILE *fd;
	char buf[1024], *fnm;

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %r15
leaq 0x2(%rdi), %r14
movzbl (%r14), %eax
cmpl $0x9, %eax
je 0x9e6c
cmpl $0x20, %eax
jne 0x9e71
incq %r14
jmp 0x9e5e
testl %eax, %eax
je 0x9ee9
leaq 0x1af1f(%rip), %rsi     # 0x24d9b
movq %r14, %rdi
callq 0x4270
testq %rax, %rax
je 0x9ee2
movq %rax, %rbx
cmpl $0x0, 0x2eb85(%rip)     # 0x38a18
jne 0x9ef6
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x41a0
testq %rax, %rax
je 0x9eca
movq %rsp, %r14
movq %r14, %rdi
callq 0x9cd1
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x41a0
testq %rax, %rax
jne 0x9ead
cmpl $0x0, 0x2eb47(%rip)     # 0x38a18
jne 0x9f19
movq %rbx, %rdi
callq 0x77d0
callq 0x9dad
jmp 0x9ee9
cmpb $0x4c, 0x1(%r15)
jne 0x9f36
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x2c0fb(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x193e2(%rip), %rsi     # 0x232e9
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41d0
jmp 0x9e95
movq 0x2c0d8(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x19997(%rip), %rsi     # 0x238c1
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41d0
jmp 0x9ed3
movq 0x2c0bb(%rip), %rax     # 0x35ff8
movq (%rax), %rdi
leaq 0x19962(%rip), %rsi     # 0x238a9
movq %r15, %rdx
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/modex.c
// Function: add_sed
void
add_sed(char *z)
{	char *n;
	int ln = strlen(z);
	if (strcmp(sedproc_info, "cat") == 0)
	{	n = (char *) e_malloc(ln + 1);
		strcpy(n, z);
	} else
	{	ln += strlen(sedproc_info) + strlen(" | ");
		n = (char *) e_malloc(ln + 1);
		sprintf(n, "%s | %s", sedproc_info, z);
	}
	sedproc_info = n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4110
movq %rax, %r14
movq 0x2c264(%rip), %r15     # 0x361d8
leaq 0x1856e(%rip), %rsi     # 0x224e9
movq %r15, %rdi
callq 0x41c0
testl %eax, %eax
je 0x9fbb
movq %r15, %rdi
callq 0x4110
leal (%r14,%rax), %edi
addl $0x4, %edi
callq 0x6321
movq %rax, %r14
movq 0x2c233(%rip), %rdx     # 0x361d8
leaq 0x19921(%rip), %rsi     # 0x238cd
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x42a0
jmp 0x9fd4
incl %r14d
movl %r14d, %edi
callq 0x6321
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movq %r14, 0x2c1fd(%rip)     # 0x361d8
popq %rbx
popq %r14
popq %r15
retq