LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: new_hashtab
hashtab_t *
new_hashtab(void)
{	hashtab_t *that;

	if (freehtab)
	{	that = freehtab;
		freehtab = that->nxt;
		if (that->tsize != INIT_HASHTAB_SIZE)
		{	fprintf(stderr, "cannot happen nht\n");
			exit(1);
		}
		memset(that->tab, 0, sizeof(symentry_t*) * that->tsize);
	} else
	{	that = (hashtab_t *) emalloc(sizeof(hashtab_t));
		that->tsize = INIT_HASHTAB_SIZE;
		that->tab = (symentry_t **) emalloc( sizeof(symentry_t*) * that->tsize );
	}
	that->nent = 0;

	return that;
}

// Assembly:
pushq %rbx
movq 0x33fdd(%rip), %rbx     # 0x3a2c0
testq %rbx, %rbx
je 0x630a
movq 0x10(%rbx), %rax
movq %rax, 0x33fcd(%rip)     # 0x3a2c0
cmpl $0x11, (%rbx)
jne 0x6337
movq 0x8(%rbx), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x3150
jmp 0x632b
movl $0x18, %edi
callq 0x5fdd
movq %rax, %rbx
movl $0x11, (%rax)
movl $0x88, %edi
callq 0x5fdd
movq %rax, 0x8(%rbx)
movl $0x0, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x3397
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: getscoop
scopetab_t **
getscoop(int n)
{	Scoop *s, *prevs = (Scoop *) 0;
	scopetab_t **g = (scopetab_t **) 0;

	for (s = scoop; s; prevs = s, s = s->nxt)
		if (s->n == n)
		{	g = s->g;
			if (!prevs)
				scoop = s->nxt;
			else
				prevs->nxt = s->nxt;
				
			s->n = 0;
			s->g = (scopetab_t **) 0;
			s->nxt = freescoop;
			freescoop = s;
			break;
		}
	if (!g)
		g = (scopetab_t **) emalloc( sizeof(scopetab_t*) * n );

	return g;
}

// Assembly:
movq 0x33d9b(%rip), %rcx     # 0x3a2c8
testq %rcx, %rcx
je 0x6593
cmpl %edi, (%rcx)
jne 0x653a
xorl %edx, %edx
jmp 0x6550
movq %rcx, %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6593
movq %rax, %rdx
movq %rcx, %rax
cmpl %edi, (%rcx)
jne 0x653d
movq 0x8(%rcx), %rax
leaq 0x10(%rdx), %rsi
testq %rdx, %rdx
leaq 0x33d66(%rip), %rdx     # 0x3a2c8
cmovneq %rsi, %rdx
movq 0x10(%rcx), %rsi
movq %rsi, (%rdx)
movl $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
movq 0x33d4e(%rip), %rdx     # 0x3a2d0
movq %rdx, 0x10(%rcx)
movq %rcx, 0x33d43(%rip)     # 0x3a2d0
testq %rax, %rax
je 0x6593
retq
movslq %edi, %rdi
shlq $0x3, %rdi
jmp 0x5fdd
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: new_scopetab
scopetab_t*
new_scopetab(scopetab_t *mom)
{	scopetab_t *that;

	if (freestab)
	{	that = freestab;
		freestab = that->parent;
		memset(that, 0, sizeof(scopetab_t));
	} else
		that = (scopetab_t *) emalloc(sizeof(scopetab_t));

	if (0)
	printf("new scope tab %p, level %d\n", that, mom?mom->level+1:EXTERN_SCOPE);

	that->size = INIT_CHILD_SIZE;

	that->children = getscoop(that->size);

	that->parent = mom;
	if (mom)
		that->level = mom->level + 1;
	else
		that->level = EXTERN_SCOPE;

	return that;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x33d2b(%rip), %rbx     # 0x3a2d8
testq %rbx, %rbx
je 0x65d5
movq 0x10(%rbx), %rax
movq %rax, 0x33d1b(%rip)     # 0x3a2d8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
jmp 0x65e2
movl $0x38, %edi
callq 0x5fdd
movq %rax, %rbx
movl $0x4, 0x2c(%rbx)
movl $0x4, %edi
callq 0x6526
movq %rax, 0x30(%rbx)
movq %r14, 0x10(%rbx)
testq %r14, %r14
je 0x6608
movl 0x4(%r14), %eax
incl %eax
jmp 0x660d
movl $0x1, %eax
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: check_struct_use
void
check_struct_use(FILE *fd, scopetab_t *that)
{	scopetab_t *z;
	symentry_t *x;
	int mustcheck, j;

	vis_p = 1;
	if (that->htab)
	{	mustcheck = 0;
		for (z = that; z; z = z->parent)
			if (z->owner
			&&  strcmp(z->owner, "-") != 0)
			{	if (z->owner_t == TN_OBJ_DEF)
					mustcheck = 1;
				break;
			}

		if (mustcheck)
		for (j = 0; j < that->htab->tsize; j++)
		for (x = that->htab->tab[j]; x; x = x->next)
		{
#if DBG
			printf("%s (%u)	is %sused, owner:	%s	type: %d\n",
				x->nme->str, x, x->used?"":"un",
				that->owner?that->owner:"--",
				that->owner_t);
#endif
			if (!uno_ignore(x))	/* unused field */
			{	fprintf(fd, "%s\t%s\t%s\t%d\n",
					(x->used)?"y":"z",	/* set in dflow.c */
					x->nme->str,
					x->node->hdr.fnm,
					x->node->hdr.line);
			}
		}
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0x337ec(%rip)     # 0x3a2e0
movq 0x8(%rsi), %rax
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x6bbe
movq %rbx, %rcx
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0x6b23
cmpb $0x2d, (%rdx)
jne 0x6b31
cmpb $0x0, 0x1(%rdx)
jne 0x6b31
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x6b0f
jmp 0x6bbe
cmpl $0x18, 0x20(%rcx)
jne 0x6bbe
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x6bbe
leaq 0x19047(%rip), %rbp     # 0x1fb8f
leaq 0x1924d(%rip), %r15     # 0x1fd9c
xorl %r13d, %r13d
movq 0x8(%rax), %rdx
movq (%rdx,%r13,8), %r12
testq %r12, %r12
je 0x6bb3
movq %r12, %rdi
callq 0x1342b
testl %eax, %eax
jne 0x6ba3
cmpw $0x0, 0x22(%r12)
movq %rbp, %rdx
leaq 0x1922d(%rip), %rax     # 0x1fda9
cmoveq %rax, %rdx
movq 0x8(%r12), %rax
movq 0x10(%r12), %rsi
movq 0x8(%rax), %rcx
movq 0x8(%rsi), %r8
movl 0x10(%rsi), %r9d
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0x6b5f
movq 0x8(%rbx), %rax
movl (%rax), %ecx
incq %r13
movslq %ecx, %rdx
cmpq %rdx, %r13
jl 0x6b52
cmpl $0x0, 0x28(%rbx)
jle 0x6be3
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x6ad9
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x6bc7
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]Uno/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (0) 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 0x6c0e
leaq 0x315bd(%rip), %rax     # 0x38238
testb $0x2, (%rax)
jne 0x6c88
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x19111(%rip), %rdi     # 0x1fdab
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: new_symtab
symtab_t*
new_symtab(void)
{	symtab_t *that;

	if (freesymt)
	{	that = freesymt;
		freesymt = that->nxt;
		memset(that, 0, sizeof(symtab_t));
	} else
		that = (symtab_t *) emalloc(sizeof(symtab_t));

	that->root = new_scopetab(NULL);
	that->clevel = EXTERN_SCOPE;
	that->current = that->root;

	return that;
}

// Assembly:
pushq %rbx
movq 0x33635(%rip), %rbx     # 0x3a2e8
testq %rbx, %rbx
je 0x6ccf
movq 0x18(%rbx), %rax
movq %rax, 0x33625(%rip)     # 0x3a2e8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x6cdc
movl $0x20, %edi
callq 0x5fdd
movq %rax, %rbx
xorl %edi, %edi
callq 0x659f
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: st_exit_scope
void
st_exit_scope(symtab_t *that)
{
	if (!that) return;

	(that->clevel)--;
	if (that->current->level > that->clevel)
		that->current = that->current->parent;
}

// Assembly:
testq %rdi, %rdi
je 0x6e6a
movl 0x8(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpl %ecx, 0x4(%rax)
jl 0x6e6a
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) emalloc( sizeof(context_t) );

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

	return that;
}

// Assembly:
pushq %rbx
movl $0x18, %edi
callq 0x5fdd
movq %rax, %rbx
callq 0x6cab
movq %rax, (%rbx)
callq 0x6cab
movq %rax, 0x8(%rbx)
callq 0x6cab
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: free_context
void
free_context(context_t *that)
{
	if (!that) return;

	free_symtab(that->labels);
	free_symtab(that->tags);
	free_symtab(that->syms);

	efree(that);
}

// Assembly:
testq %rdi, %rdi
je 0x6f2a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x6edd
movq (%r14), %rdi
callq 0x70a0
movq 0x33416(%rip), %rax     # 0x3a2e8
movq %rax, 0x18(%r14)
movq %r14, 0x3340b(%rip)     # 0x3a2e8
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x6f00
movq (%r14), %rdi
callq 0x70a0
movq 0x333f3(%rip), %rax     # 0x3a2e8
movq %rax, 0x18(%r14)
movq %r14, 0x333e8(%rip)     # 0x3a2e8
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x6f23
movq (%rbx), %rdi
callq 0x70a0
movq 0x333d0(%rip), %rax     # 0x3a2e8
movq %rax, 0x18(%rbx)
movq %rbx, 0x333c5(%rip)     # 0x3a2e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: enter_scope
int
enter_scope(context_t *that)
{
	if (!that) return 0;

#ifdef  MORE_VERBOSE
	printf("	Enter Scope: %d\n", that->syms->clevel + 1);
#endif
	st_enter_scope(that->labels);
	st_enter_scope(that->tags);

	return st_enter_scope(that->syms);
}

// Assembly:
testq %rdi, %rdi
je 0x6f4a
movq (%rdi), %rax
incl 0x8(%rax)
movq 0x8(%rdi), %rax
incl 0x8(%rax)
movq 0x10(%rdi), %rcx
movl 0x8(%rcx), %eax
incl %eax
movl %eax, 0x8(%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: exit_scope
void
exit_scope(context_t *that)
{
#ifdef  MORE_VERBOSE
	printf("	Exit Scope: %d\n", that->syms->clevel);
#endif
	if (!that) return;

	st_exit_scope(that->labels);
	st_exit_scope(that->tags);
	st_exit_scope(that->syms);
}

// Assembly:
testq %rdi, %rdi
je 0x6fba
movq (%rdi), %rax
testq %rax, %rax
je 0x6f74
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x6f74
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x6f97
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x6f97
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x6fba
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x6fba
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: add_constant
void
add_constant(char *p)
{	Cname *s;

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

	s = (Cname *) emalloc(sizeof(Cname));
	s->vn = (char *) emalloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->nxt = cnames;
	cnames = s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x332ed(%rip), %r14     # 0x3a2f0
testq %r14, %r14
je 0x701d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3190
testl %eax, %eax
je 0x705b
movq 0x8(%r14), %r14
jmp 0x7003
movl $0x10, %edi
callq 0x5fdd
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x332a0(%rip), %rax     # 0x3a2f0
movq %rax, 0x8(%r14)
movq %r14, 0x33295(%rip)     # 0x3a2f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: is_constant
int
is_constant(char *p)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp((const char *) p, s->vn) == 0)
			return 1;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x33281(%rip), %r15     # 0x3a2f0
xorl %ebx, %ebx
testq %r15, %r15
je 0x7098
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3190
testl %eax, %eax
je 0x7093
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x7079
jmp 0x7098
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: po_deltabs
static void
po_deltabs(scopetab_t *that)
{	int j;

	if (!that) return;

	for (j = 0; j < that->nchild; j++)
		po_deltabs(that->children[j]);

 	free_scopetab(that);
}

// Assembly:
testq %rdi, %rdi
je 0x7174
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
jle 0x70d3
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x70a0
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x70ba
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x711b
cmpl $0x0, (%r14)
jle 0x7109
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x7175
movq 0x8(%r14), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x70e5
movq 0x331b0(%rip), %rax     # 0x3a2c0
movq %rax, 0x10(%r14)
movq %r14, 0x331a5(%rip)     # 0x3a2c0
movq 0x331ae(%rip), %rax     # 0x3a2d0
testq %rax, %rax
je 0x7134
movq 0x10(%rax), %rcx
movq %rcx, 0x3319e(%rip)     # 0x3a2d0
jmp 0x713e
movl $0x18, %edi
callq 0x5fdd
movl 0x2c(%rbx), %ecx
movl %ecx, (%rax)
movq 0x30(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x33176(%rip), %rcx     # 0x3a2c8
movq %rcx, 0x10(%rax)
movq %rax, 0x3316b(%rip)     # 0x3a2c8
movq 0x33174(%rip), %rax     # 0x3a2d8
movq %rax, 0x10(%rbx)
movq %rbx, 0x33169(%rip)     # 0x3a2d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/symtab.c
// Function: free_symlist
static void
free_symlist(symentry_t *list)
{
	if (list)
	{	free_symlist(list->next);
		memset(list, 0, sizeof(symentry_t));	/* was symentry * */
		list->next = fses;
		fses = list;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x71b0
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x7175
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
movq 0x33114(%rip), %rax     # 0x3a2b8
movq %rax, 0x38(%rbx)
movq %rbx, 0x33109(%rip)     # 0x3a2b8
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/tree.c
// Function: make_node
treenode *
make_node(tn_t type)
{
    treenode *tmp_node;

    tmp_node = (treenode *) HeapAlloc(Parse_TOS->node_heap);

    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_node.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = NODE_T;
    tmp_node->hdr.type  = type;
    tmp_node->hdr.defuse = 0;
    tmp_node->hdr.fnm = Parse_TOS->filename;
    tmp_node->hdr.line = Parse_TOS->yylineno;

    tmp_node->lnode = (treenode *) NULL;
    tmp_node->rnode = (treenode *) NULL;
    tmp_node->syment = (symentry_t *) NULL;

    return tmp_node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x30af7(%rip), %r14     # 0x381d8
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x5eb2
testq %rax, %rax
je 0x7725
movl $0x4, (%rax)
movl %ebx, 0x1c(%rax)
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movq (%r14), %rdx
movq 0x10(%rdx), %rsi
movq %rsi, 0x8(%rax)
movl 0x20(%rdx), %edx
movl %edx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %rcx, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3419
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/tree.c
// Function: find_func_name
leafnode *
find_func_name(treenode *n)
{
	while (n && (n->hdr.which != LEAF_T))
	{	switch(n->hdr.which) {
		case NODE_T:
			switch(n->hdr.type) {
			case TN_DECL:
				n = n->rnode;
				break;
			case TN_FUNC_DECL:
				n = n->lnode;
				break;
			case TN_ARRAY_DECL:
				fprintf(stderr,
					"%s: error: unexpected node in find_func_name;\n"
					"\tnode: %s, type: %s (%s:%d)\n", progname,
						name_of_nodetype(n->hdr.which),
						name_of_node(n->hdr.type),
						n->hdr.fnm, n->hdr.line);
				n = n->rnode;	/* 1/4/10: a guess */
				break;
			default:
				goto bad;
			}
			break;
		case FOR_T:
			if (n->hdr.type == TN_FUNC_DEF)
				n = ((for_node *) n)->test;
			break;
		default:
bad:			fprintf(stderr,
				"%s: error: bad node in find_func_name;\n"
				"	node: %s, type: %s\n",
				progname, name_of_nodetype(n->hdr.which),
				name_of_node(n->hdr.type));
			n = NULL;
			break;
	}	}

	return (leafnode*) n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7a67
movq %rdi, %rbx
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x7a4a
cmpl $0x4, %eax
jne 0x7a6b
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
je 0x7a58
movl $0x48, %r14d
cmpl $0x5, %eax
je 0x7a5e
cmpl $0x6, %eax
jne 0x7aa5
movq %rbx, %rdi
callq 0x36a3
jmp 0x7a5e
movl $0x48, %r14d
cmpl $0x1, 0x1c(%rbx)
je 0x7a5e
jmp 0x7a62
movl $0x40, %r14d
movq (%rbx,%r14), %rbx
testq %rbx, %rbx
jne 0x7a1c
xorl %ebx, %ebx
jmp 0x7a70
cmpl $0x1, %eax
jne 0x7a7f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x30572(%rip), %rcx     # 0x37ff8
movq (%rcx), %r14
leaq 0x306e8(%rip), %rcx     # 0x38178
movq (%rcx), %r15
testl %eax, %eax
je 0x7ac2
cmpl $0x2, %eax
jne 0x7acb
leaq 0x18f6c(%rip), %r12     # 0x20a0f
jmp 0x7ad2
movq 0x3054c(%rip), %rax     # 0x37ff8
movq (%rax), %r14
leaq 0x306c2(%rip), %rax     # 0x38178
movq (%rax), %r15
leaq 0x18f5a(%rip), %r12     # 0x20a1a
jmp 0x7ad2
leaq 0x18f38(%rip), %r12     # 0x20a01
jmp 0x7ad2
leaq 0x18f4f(%rip), %r12     # 0x20a21
movl 0x1c(%rbx), %edi
callq 0x7937
leaq 0x18bd9(%rip), %rsi     # 0x206ba
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x31a0
jmp 0x7a70
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/treestk.c
// Function: new_stk_item
Stk_Item  *
new_stk_item( FILE *fp, char *fname )
{
    Stk_Item *stk_item;

	if (freestk)
	{	stk_item = freestk;
		freestk = freestk->next;
		memset(stk_item, 0, STK_ITEM_SZE);
	} else
		stk_item = emalloc(STK_ITEM_SZE);

    stk_item->filename = emalloc(strlen(fname)+1);
    strcpy(stk_item->filename, fname);

    if ((stk_item->yybuff = yy_create_buffer(fp, YYBUFF_SIZE )) == NULL){
        efree(stk_item->filename);
        efree(stk_item);
        return((Stk_Item *) NULL);
    }

    if ((stk_item->node_heap  = CreateHeap(MX_NODE_SZE, 0)) == NULL){
        efree(stk_item->filename);
        yy_delete_buffer( stk_item->yybuff );
        efree(stk_item);
        return((Stk_Item *) NULL);
    }

    stk_item->yyin     = fp;

    stk_item->yylineno = 1;
    stk_item->yycolno  = 0;
    stk_item->yynxtcol = 0;

    stk_item->parse_tree = (treenode *) NULL;

    stk_item->next = (Stk_Item *) NULL;

    return(stk_item);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x326ca(%rip), %rbx     # 0x3a320
testq %rbx, %rbx
je 0x7c7a
movq 0x38(%rbx), %rax
movq %rax, 0x326ba(%rip)     # 0x3a320
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x7c87
movl $0x40, %edi
callq 0x5fdd
movq %rax, %rbx
movq %r15, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3090
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xd336
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x7cf0
movl $0x60, %edi
xorl %esi, %esi
callq 0x5cc4
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x7cfb
movq %r14, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x38(%rbx)
jmp 0x7d17
movq 0x10(%rbx), %rdi
callq 0x5fdc
jmp 0x7d0d
movq 0x10(%rbx), %rdi
callq 0x5fdc
movq 0x30(%rbx), %rdi
callq 0xd7f2
movq %rbx, %rdi
callq 0x5fdc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/treestk.c
// Function: delete_stk_item
void
delete_stk_item(Stk_Item *stk_item)
{
	if (!stk_item)
		return;
#ifdef PC
	if (stk_item->yybuff)
		yy_delete_buffer(stk_item->yybuff);
#endif
	if (stk_item->node_heap)
	{	DestroyHeap(stk_item->node_heap);
		memset(stk_item, 0, sizeof(Stk_Item));
	}

	stk_item->next = freestk;
	freestk = stk_item;
}

// Assembly:
testq %rdi, %rdi
je 0x7d60
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x7d4d
callq 0x5d5e
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
movq 0x325cc(%rip), %rax     # 0x3a320
movq %rax, 0x38(%rbx)
movq %rbx, 0x325c1(%rip)     # 0x3a320
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/treestk.c
// Function: tree_parse
int
tree_parse(TreeStack *treestk, int parse_all)
{
    int cnt = 0;

    if (is_empty(treestk))
        return(0);

    do {
	yyparse();	/* returns 1 on error 0 on accept */
        cnt++;
        get_next_file(treestk);

        if (is_empty(treestk))
            break;

    } while (parse_all);

    return(cnt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7e7c
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x7e7c
movl %esi, %ebp
xorl %ebx, %ebx
callq 0xdbd8
incl %ebx
movq %r14, %rdi
callq 0x7e83
testl %ebp, %ebp
je 0x7e7c
cmpq $0x0, (%r14)
jne 0x7e63
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/lexer.c
// Function: yy_get_previous_state
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);
	yy_current_state += YY_AT_BOL();

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		if ( yy_accept[yy_current_state] )
			{
			(yy_last_accepting_state) = yy_current_state;
			(yy_last_accepting_cpos) = yy_cp;
			}
		if ( *yy_cp )
			{
			YY_CHAR yy_c = YY_SC_TO_UI(*yy_cp);
			if ( yy_accept[yy_current_state] )
				{
				(yy_last_accepting_state) = yy_current_state;
				(yy_last_accepting_cpos) = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			}
		else
			yy_current_state = yy_NUL_trans[yy_current_state];
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x2cddd(%rip), %rax     # 0x3a350
movq 0x2cdde(%rip), %rcx     # 0x3a358
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %eax
addl 0x2cdc5(%rip), %eax     # 0x3a34c
movq 0x2cdea(%rip), %rcx     # 0x3a378
movq 0x2cdcb(%rip), %rdx     # 0x3a360
cmpq %rdx, %rcx
jae 0xd622
leaq 0x1380b(%rip), %rsi     # 0x20db0
leaq 0x1d7f4(%rip), %rdi     # 0x2ada0
leaq 0x1856d(%rip), %r8      # 0x25b20
leaq 0x13c86(%rip), %r9      # 0x21240
leaq 0x18eff(%rip), %r10     # 0x264c0
leaq 0x18a28(%rip), %r11     # 0x25ff0
movslq %eax, %rbx
cmpw $0x0, (%rsi,%rbx,2)
je 0xd5df
movl %eax, 0x2cd94(%rip)     # 0x3a36c
movq %rcx, 0x2cd91(%rip)     # 0x3a370
movb (%rcx), %bpl
testb %bpl, %bpl
je 0xd617
movzbl %bpl, %r14d
movswq (%r8,%rbx,2), %r15
addq %r14, %r15
movswl (%r9,%r15,2), %ebp
cmpl %ebp, %eax
je 0xd610
movswq (%r11,%rbx,2), %rbx
movswq (%r8,%rbx,2), %r15
addq %r14, %r15
cmpw (%r9,%r15,2), %bx
jne 0xd5fc
movswl (%r10,%r15,2), %eax
jmp 0xd61a
movl (%rdi,%rbx,4), %eax
incq %rcx
cmpq %rdx, %rcx
jb 0xd5c8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: dep_node
DuG *
dep_node(SymList *a, int imark)
{	DuG *g;

	for (g = d_g; g; g = g->nxt)
		if (g->sm == a->sm)
		{	g->marks |= imark;
			goto done;
		}

	g = (DuG *) emalloc(sizeof(DuG));

	if (!a->sm) printf("%s: dep_node without symbol\n", progname);

	g->sm = a->sm;
	g->marks = imark;
	g->rdcls |= RealDecls;
	g->d_e = (DuGP *) 0;
	g->nxt = d_g;
	d_g = g;
done:
	return g;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x2f24e(%rip), %rbx     # 0x3ebd0
testq %rbx, %rbx
je 0xf999
movq 0x8(%r14), %rax
cmpq %rax, (%rbx)
je 0xf9f6
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xf98b
movl $0x20, %edi
callq 0x5fdd
movq %rax, %rbx
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xf9cb
leaq 0x287c2(%rip), %rax     # 0x38178
movq (%rax), %rsi
leaq 0x1fb46(%rip), %rdi     # 0x2f506
xorl %eax, %eax
callq 0x3100
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
movl 0x2f201(%rip), %eax     # 0x3ebd8
orl %eax, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x2f1e7(%rip), %rax     # 0x3ebd0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2f1dc(%rip)     # 0x3ebd0
jmp 0xf9f9
orl %ebp, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: rel_all
void
rel_all(SymList *s)
{
	if (!s) return;

	rel_all(s->all);
	s->all = freesyml;
	freesyml = s;
}

// Assembly:
testq %rdi, %rdi
je 0xffc1
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff9c
movq 0x2ec2b(%rip), %rax     # 0x3ebe0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2ec20(%rip)     # 0x3ebe0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: symadd
SymList *
symadd(symentry_t *sm, int mark)
{	SymList *sl;

	if (freesyml)
	{	sl = freesyml;
		freesyml = freesyml->all;
		memset(sl, 0, sizeof(SymList));
	} else
		sl = (SymList *) emalloc(sizeof(SymList));

	sl->nxt = (SymList *) 0;
	sl->mark = mark;
	sl->sm  = sm;

	sl->all = allsym;
	allsym = sl;

	return sl;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2ebf5(%rip), %rax     # 0x3ebe0
testq %rax, %rax
je 0x10007
movq 0x18(%rax), %rcx
movq %rcx, 0x2ebe5(%rip)     # 0x3ebe0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x10011
movl $0x20, %edi
callq 0x5fdd
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
movq %rbx, 0x8(%rax)
movq 0x2ebc1(%rip), %rcx     # 0x3ebe8
movq %rcx, 0x18(%rax)
movq %rax, 0x2ebb6(%rip)     # 0x3ebe8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: set_fbase
void
set_fbase(int ln, char *s)
{	Fbase *f;

	fbase = (Fbase *) 0;

	f = (Fbase *) emalloc(sizeof(Fbase));
	f->nm = (char *) emalloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->ln = ln;
	f->fcalls = (Fbase *) 0;
	f->nxt = fbase;
	fbase = f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
movq %r15, 0x2eba1(%rip)     # 0x3ebf0
movl $0x20, %edi
callq 0x5fdd
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %ebp, 0x8(%r14)
movq %r15, 0x10(%r14)
movq 0x2eb66(%rip), %rax     # 0x3ebf0
movq %rax, 0x18(%r14)
movq %r14, 0x2eb5b(%rip)     # 0x3ebf0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: check_else
void
check_else(treenode *p, treenode *n, int depth)	/* check that any if-then-else-if-then chain ends with and else block */
{	if_node *ifn;

	if (Verbose)
	{	if (p)
			printf("%d	B %s:%d -> %d (if=%d) %d\n",
			depth, p->hdr.fnm, p->hdr.line, (n)?n->hdr.which:0, IF_T, (n)?n->hdr.type:0);
		if (n)
			printf("%d	C %s:%d \n", depth, n->hdr.fnm, n->hdr.line);
	}

	if (n)
	{	switch (n->hdr.which) {
		case IF_T:	/* 2	-- if or a cond-expr */
			ifn = (if_node *) n;
			if (ifn->hdr.type == TN_IF)	/* 27 */
			{	if (ifn->else_n == NULL && depth > 0)
				{	printf("uno: %s:%d: missing else\n",
						n->hdr.fnm, n->hdr.line);
				} else
				{	check_else(p, (treenode *) ifn->else_n, depth+1);
				}
			}
			break;
		case NODE_T:	/* 4 */
			if (n->hdr.type == TN_STEMNT	/* 35 */
			||  n->hdr.type == TN_BLOCK)	/* 4 */
			{	check_else(p, n->lnode, depth+1);
				check_else(p, n->rnode, depth+1);
			}
			break;
		default:
			break;
	}	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x27d1d(%rip), %rbp     # 0x38238
leaq 0x1f0e6(%rip), %r12     # 0x2f608
leaq 0x1f0c2(%rip), %r13     # 0x2f5eb
cmpl $0x0, (%rbp)
je 0x10542
testq %r14, %r14
je 0x1056e
testq %r15, %r15
je 0x1054c
movl (%r15), %r8d
movl 0x1c(%r15), %eax
jmp 0x10551
testq %r15, %r15
jne 0x10587
jmp 0x105d9
xorl %r8d, %r8d
xorl %eax, %eax
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movl %eax, (%rsp)
movq %r13, %rdi
movl %ebx, %esi
movl $0x2, %r9d
xorl %eax, %eax
callq 0x3100
testq %r15, %r15
je 0x105d9
movq 0x8(%r15), %rdx
movl 0x10(%r15), %ecx
movq %r12, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
movl (%r15), %eax
cmpl $0x4, %eax
je 0x105b2
cmpl $0x2, %eax
jne 0x105d9
cmpl $0x1b, 0x1c(%r15)
jne 0x105d9
movq 0x50(%r15), %rax
testl %ebx, %ebx
jle 0x105a8
testq %rax, %rax
je 0x105e8
incl %ebx
movq %rax, %r15
jmp 0x10529
movl 0x1c(%r15), %eax
cmpl $0x23, %eax
je 0x105c0
cmpl $0x4, %eax
jne 0x105d9
movq 0x40(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0x10501
movq 0x48(%r15), %r15
jmp 0x10529
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rsi
movl 0x10(%r15), %edx
leaq 0x1f01e(%rip), %rdi     # 0x2f615
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: track_types
static void
track_types(DefUse *d1, leafnode *leaf)		/* Experimental */
{	symentry_t	*se;
	char	*x, *y, *k, *m;
	int	z;

	if (!type_check)
		return;

	if (d1 == NULL
	||  leaf == NULL
	||  leaf->syment == NULL)
	{	return;
	}

	se = leaf->syment;

	if (se == NULL || se->fn[0] == '/')
	{	return;
	}

	if (se->kind == TYPEDEF_ENTRY)
	{	x = se->nme->str;
	} else
	{	x = x_stmnt(se->node);
		for (z = 0; xtable[z] != NULL; z++)
		{	if (strncmp(x, xtable[z], strlen(xtable[z])) == 0)
			{	x += strlen(xtable[z]);
				while (*x == ' ') x++;
		}	}
		y = (char *) 1;
		for (k = x; y != NULL; k = ++y)
		{	y = strstr(k, se->nme->str);
			if (y != NULL)
			{	m = y+strlen(se->nme->str);
				if ((*(y-1) == ' ' || *(y-1) == '\t' || *(y-1) == '*')
				&&  (*m == ';' || *m == ' ' || *m == '\t'
				  || *m == '=' || *m == '(' || *m == ',' || *m == '*'))
				{	*y = '\0';
					break;
				}
			} else
			{
				break;
		}	}
		if (strchr(x, ';') != NULL
		||  strchr(x, '=') != NULL
		||  strchr(x, ',') != NULL)
		{	x = "?";
		}
	}

	if (se->kind != PARAM_ENTRY)
	{	d1->der_type = cache_str(x);
	}

	if (0) printf("%s:%d: [%d] <%s> -- %s (type)\n",
		se->fn, se->ln,
		se->kind,
		se->nme->str,
		x);
}

// Assembly:
testq %rdi, %rdi
je 0x11887
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x26b6e(%rip), %rax     # 0x38288
cmpl $0x0, (%rax)
je 0x11879
movq 0x38(%rsi), %r15
testq %r15, %r15
je 0x11879
movq 0x28(%r15), %rax
cmpb $0x2f, (%rax)
je 0x11879
movq %rdi, %rbx
cmpl $0x1, (%r15)
jne 0x11753
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
jmp 0x11867
movq %r15, (%rsp)
movq 0x10(%r15), %rdi
callq 0x5cbe
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x26594(%rip), %r13     # 0x37d00
movq (%r13,%rbp,8), %r12
movq %r12, %rdi
callq 0x30d0
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3080
testl %eax, %eax
jne 0x117a2
leaq (%r14,%r15), %rax
decq %rax
leaq 0x1(%rax), %r14
cmpb $0x20, 0x1(%rax)
movq %r14, %rax
je 0x11795
incq %rbp
cmpq $0x3, %rbp
jne 0x1176c
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3280
testq %rax, %rax
je 0x11826
movq %rax, %r12
movabsq $0x40100000200, %r13    # imm = 0x40100000200
movabsq $0x2800150100000200, %rbp # imm = 0x2800150100000200
movzbl -0x1(%r12), %eax
cmpq $0x2a, %rax
ja 0x11809
btq %rax, %r13
jae 0x11809
movq %r15, %rdi
callq 0x30d0
movzbl (%r12,%rax), %eax
cmpq $0x3d, %rax
ja 0x11809
btq %rax, %rbp
jb 0x11821
incq %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3280
movq %rax, %r12
testq %rax, %rax
jne 0x117de
jmp 0x11826
movb $0x0, (%r12)
movq %r14, %rdi
movl $0x3b, %esi
callq 0x30f0
testq %rax, %rax
movq (%rsp), %r15
jne 0x11860
movq %r14, %rdi
movl $0x3d, %esi
callq 0x30f0
testq %rax, %rax
jne 0x11860
movq %r14, %rdi
movl $0x2c, %esi
callq 0x30f0
testq %rax, %rax
je 0x11867
leaq 0xe58b(%rip), %r14      # 0x1fdf2
cmpl $0x8, (%r15)
je 0x11879
movq %r14, %rdi
callq 0x11ac1
movq %rax, 0x28(%rbx)
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]Uno/Src/dflow.c
// Function: add_aio
static void
add_aio(DefUse *d, treenode *n)
{	ArList *nio;

	if (!d)
	{	if (0 && !exclude_location(n))
			printf("uno: %s:%d aio without d to attach to\n",
			n->hdr.fnm, n->hdr.line);
		return;
	}
	for (nio = d->aio; nio; nio = nio->nxt)
		if (nio->tn == n)
			return;

	nio = get_arlist();
	nio->tn = n;
	nio->nxt = d->aio;
	d->aio = nio;
}

// Assembly:
testq %rdi, %rdi
je 0x11ac0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x11aa0
cmpq %r14, (%rax)
je 0x11ab9
movq 0x8(%rax), %rax
jmp 0x11a90
movl $0x10, %edi
callq 0x5fdd
movq %r14, (%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: cache_str
static char *
cache_str(char *s)
{	Cached *c;
	for (c = cst; c; c = c->nxt)
	{	if (strcmp(c->nm, s) == 0)
		{	return c->nm;
	}	}
	c = (Cached *) emalloc(sizeof(Cached));
	c->nm = (char *) emalloc(strlen(s)+1);
	strcpy(c->nm, s);
	c->nxt = cst;
	cst = c;
	return c->nm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4e950(%rip), %r15     # 0x60420
testq %r15, %r15
je 0x11aed
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
testl %eax, %eax
je 0x11b2e
movq 0x8(%r15), %r15
jmp 0x11ad0
movl $0x10, %edi
callq 0x5fdd
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x4e900(%rip), %rax     # 0x60420
movq %rax, 0x8(%r14)
movq %r14, 0x4e8f5(%rip)     # 0x60420
movq (%r14), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/dflow.c
// Function: merge_syms
static SymList *
merge_syms(SymList *s1, SymList *s2)
{	SymList *s, *t, *ns;
	SymList *add_to_s1 = (SymList *) 0;
	SymList *last_in   = (SymList *) 0;

	/* static int mcnt=1; */

	if (!s1) return s2;
	if (!s2) return s1;

	for (t = s2; t; t = t->nxt)
	{	for (s = s1; s; s = s->nxt)
			if (s->sm == t->sm
			&&  s->mark == t->mark)
				break;

		if (!s) /* add t */
		{	ns = symadd(t->sm, t->mark);
			/* preserve relative order */
			if (!last_in)
				add_to_s1 = last_in = ns;
			else
			{	last_in->nxt = ns;
				last_in = ns;
			}
	}	}

	if (!last_in)
		return s1;
	last_in->nxt = s1;
	s1 = add_to_s1;
	return s1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdi, %rdi
je 0x11ba9
movq %rdi, %rbx
testq %r15, %r15
je 0x11ba4
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%r15), %rdi
movq %rbx, %rax
cmpq %rdi, 0x8(%rax)
jne 0x11b6b
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
je 0x11b8f
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x11b5c
movl 0x4(%r15), %esi
callq 0xffdc
testq %r12, %r12
je 0x11b89
movq %rax, 0x10(%r12)
jmp 0x11b8c
movq %rax, %r14
movq %rax, %r12
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x11b55
testq %r12, %r12
je 0x11ba4
movq %rbx, 0x10(%r12)
jmp 0x11bac
movq %rbx, %r14
jmp 0x11bac
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/prnttree.c
// Function: print_recur
void
print_recur(treenode *root, FILE *fp)
{
	can_flush = fp;
	strcpy(PBuf, "");
	do_recur(root, 0);
	if (!viewtree) fprintf(fp, "%s", PBuf);
	can_flush = (FILE *) 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, 0x5cd3e(%rip)     # 0x6fe30
movb $0x0, 0x4d337(%rip)     # 0x60430
xorl %esi, %esi
callq 0x11d74
leaq 0x25141(%rip), %rax     # 0x38248
cmpl $0x0, (%rax)
jne 0x1311b
leaq 0x4d31d(%rip), %rdi     # 0x60430
movq %rbx, %rsi
callq 0x3140
movq $0x0, 0x5cd0a(%rip) # 0x6fe30
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: find_suppress_lines
void
find_suppress_lines(char *fn)
{	FILE	*fd;
	char	buf[1024];
	int	cnt = 0;
	ST	*nst;

	if ((fd = fopen(fn, "r")) == NULL)
	{	return;
	}

	while (fgets(buf, sizeof(buf), fd) != NULL)
	{	cnt++;
		if (strstr(buf, "@uno_suppress") != NULL)
		{	nst = (ST *) emalloc(sizeof(ST));
			nst->name = (char *) emalloc(strlen(fn)+1);
			strcpy(nst->name, fn);
			nst->line = cnt;
			nst->nxt = st;
			st = nst;
	}	}

	fclose(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x1c7d8(%rip), %rsi     # 0x2f91b
callq 0x3220
testq %rax, %rax
je 0x131ea
movq %rax, %r14
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x3170
testq %rax, %rax
je 0x131e2
movl $0x1, %ebp
leaq 0x1cab7(%rip), %r15     # 0x2fc2c
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3280
testq %rax, %rax
je 0x131cb
movl $0x18, %edi
callq 0x5fdd
movq %rax, %r13
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r13)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %ebp, 0x8(%r13)
movq 0x5cc90(%rip), %rax     # 0x6fe50
movq %rax, 0x10(%r13)
movq %r13, 0x5cc85(%rip)     # 0x6fe50
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x3170
incl %ebp
testq %rax, %rax
jne 0x13178
movq %r14, %rdi
callq 0x30c0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: read_suppress
void
read_suppress(void)
{	FILE *fd;

	if ((fd = fopen("uno_suppress", "r")) != NULL)
	{	get_suppressors(fd);
		fclose(fd);
	}

	if (working_dir != NULL)
	{	char *efn;

		efn = emalloc(strlen(working_dir)+strlen("/uno_suppress")+1);
		sprintf(efn, "%s/uno_suppress", working_dir);

		if ((fd = fopen(efn, "r")) != NULL)
		{	get_suppressors(fd);
			fclose(fd);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1ca36(%rip), %rdi     # 0x2fc3d
leaq 0x1c70d(%rip), %rsi     # 0x2f91b
callq 0x3220
testq %rax, %rax
je 0x1322b
movq %rax, %rbx
movq %rax, %rdi
callq 0x13295
movq %rbx, %rdi
callq 0x30c0
leaq 0x24fb6(%rip), %r14     # 0x381e8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1328d
callq 0x30d0
leaq 0xe(%rax), %rdi
callq 0x5fdd
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x1c9e5(%rip), %rsi     # 0x2fc3a
movq %rax, %rdi
xorl %eax, %eax
callq 0x3250
leaq 0x1c6b5(%rip), %rsi     # 0x2f91b
movq %rbx, %rdi
callq 0x3220
testq %rax, %rax
je 0x1328d
movq %rax, %rbx
movq %rax, %rdi
callq 0x13295
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: get_suppressors
static void
get_suppressors(FILE *fd)
{	char *p, buf[1024];
	ST *nst;

	while (fgets(buf, sizeof(buf), fd))
	{	if ((p = strchr(buf, '\t')) == NULL)
		{	fprintf(stderr, "uno: suppress file format <%s>\n", buf);
		} else
		{	*p++ = '\0';
			nst = (ST *) emalloc(sizeof(ST));
			nst->name = (char *) emalloc(strlen(buf)+1);
			strcpy(nst->name, buf);
			if (!isdigit((int) *p))
			{	nst->line = 0;	/* meaning all lines */
			} else
			{	nst->line = atoi(p);
			}
			nst->nxt = st;
			st = nst;
	}	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x3170
testq %rax, %rax
je 0x13383
movq %rsp, %r14
movq 0x24d2c(%rip), %rbp     # 0x37ff8
leaq 0x1ca9b(%rip), %r15     # 0x2fd6e
movq %r14, %rdi
movl $0x9, %esi
callq 0x30f0
testq %rax, %rax
je 0x13370
movq %rax, %r13
movb $0x0, (%rax)
movl $0x18, %edi
callq 0x5fdd
movq %rax, %r12
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
callq 0x3290
movq (%rax), %rcx
movsbq 0x1(%r13), %rdx
xorl %eax, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x1333d
incq %r13
movq %r13, %rdi
callq 0x3230
movl %eax, 0x8(%r12)
movq 0x5cb07(%rip), %rax     # 0x6fe50
movq %rax, 0x10(%r12)
movq %r12, 0x5cafb(%rip)     # 0x6fe50
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x3170
testq %rax, %rax
jne 0x132d3
jmp 0x13383
movq (%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x13355
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: suppress
int
suppress(char *fn, int ln)
{	ST *nst;

	for (nst = st; nst; nst = nst->nxt)
		if ((nst->line == 0 || nst->line == ln)
		&& (strcmp(nst->name, fn) == 0
		|| (strncmp(fn, "./", 2) == 0 && strcmp(nst->name, fn+2) == 0)))
		{
#if 0
			if (!nst->reported)
			fprintf(stderr, "uno: %s:%d: suppressing error report\n", fn, ln);
#endif
			nst->reported++;
			return 1;
		}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5caa9(%rip), %r13     # 0x6fe50
xorl %ebx, %ebx
testq %r13, %r13
je 0x1340c
movl %esi, %ebp
movq %rdi, %r14
leaq 0x2(%rdi), %r15
movl 0x8(%r13), %eax
testl %eax, %eax
setne %cl
cmpl %ebp, %eax
setne %al
testb %al, %cl
jne 0x133f8
movq (%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3190
testl %eax, %eax
je 0x13403
cmpb $0x2e, (%r14)
jne 0x133f8
cmpb $0x2f, 0x1(%r14)
jne 0x133f8
movq %r12, %rdi
movq %r15, %rsi
callq 0x3190
testl %eax, %eax
je 0x13403
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x133b7
jmp 0x1340c
incl 0xc(%r13)
movl $0x1, %ebx
movl %ebx, %eax
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]Uno/Src/uno_lts.c
// Function: rev_release
SymRef *
rev_release(SymRef *r)	/* release a list of symrefs */
{
	if (r)
	{	rev_release(r->nxt);
		r->nxt = dfs_free;
		dfs_free = r;
	}
	return (SymRef *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x137c5
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x137a0
movq 0x5c6a7(%rip), %rax     # 0x6fe60
movq %rax, 0x18(%rbx)
movq %rbx, 0x5c69c(%rip)     # 0x6fe60
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: custom_exit
void
custom_exit(const char *s)
{	EX *nx;
	char *col;

	col = strchr(s, ':');
	if (col)
	{	*col = '\0';
		col++;
	}

	nx = (EX *) emalloc(sizeof(EX));
	nx->f = (char *) emalloc(strlen(s)+1);
	strcpy(nx->f, s);
	if (col)
	{	nx->has_arg = 1;
		nx->arg_val = atoi(col);
	} else
		nx->has_arg = 0;
	nx->nxt = exs;
	exs = nx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x3a, %esi
callq 0x30f0
testq %rax, %rax
je 0x137ea
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
jmp 0x137ec
xorl %ebx, %ebx
movl $0x18, %edi
callq 0x5fdd
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x5fdd
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
testq %rbx, %rbx
je 0x13833
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x3230
movl %eax, 0xc(%r15)
jmp 0x1383b
movl $0x0, 0x8(%r15)
movq 0x5c626(%rip), %rax     # 0x6fe68
movq %rax, 0x10(%r15)
movq %r15, 0x5c61b(%rip)     # 0x6fe68
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_copy_ref
SymRef *
uno_copy_ref(SymRef *r)
{	SymRef *q;
	q = uno_getref(r->sm);
	q->n = r->n;
	q->status = r->status;
	q->s_val = r->s_val;
	return q;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x5c5c6(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x138b6
movq 0x18(%rax), %rcx
movq %rcx, 0x5c5b6(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x138c0
movl $0x20, %edi
callq 0x5fdd
movq %r14, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_getext
SymExt *
uno_getext(symentry_t *t)
{	SymExt *r;

	if (freesymext)
	{	r = freesymext;
		freesymext = r->nxt;
		memset(r, 0, sizeof(SymExt));
	} else
		r = (SymExt *) emalloc(sizeof(SymExt));
	r->sm = t;

	return r;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x5c58a(%rip), %rax     # 0x6fe70
testq %rax, %rax
je 0x13902
movq 0x18(%rax), %rcx
movq %rcx, 0x5c57a(%rip)     # 0x6fe70
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x1390c
movl $0x20, %edi
callq 0x5fdd
movq %rbx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: could_be_fct
void
could_be_fct(char *s)
{	Graphs *g;

	for (g = graph; g; g = g->nxt)
		if (strcmp(s, g->fctnm) == 0)
		{	if (debug)
			printf("uno: marking %s as fct in disguise\n", s);
			g->status |= 4;		/* cannot tell when this fct is called */
			break;
		}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x5c55c(%rip), %r14     # 0x6fe78
testq %r14, %r14
je 0x13943
movq %rdi, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3190
testl %eax, %eax
je 0x1393e
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x13924
jmp 0x13943
orb $0x4, 0x42(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: snap_add
int
snap_add(State *s, SymRef *r)
{	SymRef *t;

	for (t = s->snapshot; t; t = t->nxt)
		if (t->sm == r->sm
		&&  t->status == r->status)
			return 0;

	t = uno_getref(r->sm);
	t->status = r->status;
	t->n = r->n;
	t->nxt = s->snapshot;
	s->snapshot = t;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rsi), %r15
testq %rax, %rax
je 0x13976
cmpq %r15, (%rax)
jne 0x13970
movl 0x10(%rax), %ecx
cmpl 0x10(%r14), %ecx
je 0x139cc
movq 0x18(%rax), %rax
jmp 0x1395d
movq 0x5c4e3(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x13999
movq 0x18(%rax), %rcx
movq %rcx, 0x5c4d3(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x139a3
movl $0x20, %edi
callq 0x5fdd
movq %r15, (%rax)
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x8(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x139c6
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: infeasible
int
infeasible(treenode *e, treenode *v)
{	int w;
	char *s;

	if (!e || !v) return 0;

	if (e->hdr.type == TN_INT
	&&  v->hdr.tok  == IDENT)
	{	w = ((leafnode *)e)->data.ival;		/* could use const_expr evaluator here */
		s = ((leafnode *)v)->data.sval->str;

		if ((w != 0 && strcmp(s, "_false_") == 0)
		||  (w == 0 && strcmp(s,  "_true_") == 0))
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x13a21
cmpl $0x30, 0x1c(%rdi)
jne 0x13a21
cmpl $0x102, 0x18(%rsi)      # imm = 0x102
jne 0x13a21
movq 0x40(%rsi), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x40(%rdi)
je 0x13a09
leaq 0x1c34e(%rip), %rsi     # 0x2fd55
jmp 0x13a10
leaq 0x1c34d(%rip), %rsi     # 0x2fd5d
movq %rax, %rdi
callq 0x3190
testl %eax, %eax
jne 0x13a21
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq