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

	if (fses)
	{	that = fses;
		fses = fses->next;
		memset(that, 0, sizeof(symentry_t));
	} else
		that = (symentry_t *) emalloc(sizeof(symentry_t));

	that->ln = current_linenumber();	/* gjh */
	that->fn = current_filename();		/* gjh */
	return that;
}

// Assembly:
pushq %rbx
movq 0x33fd2(%rip), %rbx     # 0x3a2a8
testq %rbx, %rbx
je 0x62fa
movq 0x38(%rbx), %rax
movq %rax, 0x33fc2(%rip)     # 0x3a2a8
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x6307
movl $0x40, %edi
callq 0x61a1
movq %rax, %rbx
callq 0x10134
movl %eax, 0x24(%rbx)
callq 0x1014a
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x33df8(%rip), %rbx     # 0x3a2b0
testq %rbx, %rbx
je 0x64df
movq 0x10(%rbx), %rax
movq %rax, 0x33de8(%rip)     # 0x3a2b0
cmpl $0x11, (%rbx)
jne 0x650c
movq 0x8(%rbx), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x3150
jmp 0x6500
movl $0x18, %edi
callq 0x61a1
movq %rax, %rbx
movl $0x11, (%rax)
movl $0x88, %edi
callq 0x61a1
movq %rax, 0x8(%rbx)
movl $0x0, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x3387
// File: /workspace/github_c_makefile_star2_O1/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 0x33bbd(%rip), %rcx     # 0x3a2b8
testq %rcx, %rcx
je 0x6708
cmpl %edi, (%rcx)
jne 0x670c
xorl %edx, %edx
jmp 0x6724
xorl %eax, %eax
jmp 0x6761
xorl %eax, %eax
movq %rcx, %rsi
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x6761
movq %rsi, %rdx
movq %rcx, %rsi
cmpl %edi, (%rcx)
jne 0x6711
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rsi
leaq 0x10(%rdx), %r8
testq %rdx, %rdx
leaq 0x33b7e(%rip), %rdx     # 0x3a2b8
cmovneq %r8, %rdx
movq %rsi, (%rdx)
movl $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
movq 0x33b6a(%rip), %rdx     # 0x3a2c0
movq %rdx, 0x10(%rcx)
movq %rcx, 0x33b5f(%rip)     # 0x3a2c0
testq %rax, %rax
je 0x6767
retq
movslq %edi, %rdi
shlq $0x3, %rdi
jmp 0x61a1
// File: /workspace/github_c_makefile_star2_O1/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 0x33b47(%rip), %rbx     # 0x3a2c8
testq %rbx, %rbx
je 0x67a9
movq 0x10(%rbx), %rax
movq %rax, 0x33b37(%rip)     # 0x3a2c8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
jmp 0x67b6
movl $0x38, %edi
callq 0x61a1
movq %rax, %rbx
movl $0x4, 0x2c(%rbx)
movl $0x4, %edi
callq 0x66f4
movq %rax, 0x30(%rbx)
movq %r14, 0x10(%rbx)
testq %r14, %r14
je 0x67dc
movl 0x4(%r14), %eax
incl %eax
jmp 0x67e1
movl $0x1, %eax
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x335ee(%rip)     # 0x3a2d0
cmpq $0x0, 0x8(%rsi)
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x6db4
leaq 0x19525(%rip), %r15     # 0x20224
movq %rbx, %r12
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x6d18
movq %r15, %rsi
callq 0x3180
testl %eax, %eax
jne 0x6d27
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x6d02
jmp 0x6db4
cmpl $0x18, 0x20(%r12)
jne 0x6db4
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jle 0x6db4
leaq 0x18e4f(%rip), %rbp     # 0x1fb92
leaq 0x19072(%rip), %r15     # 0x1fdbc
xorl %r13d, %r13d
movq 0x8(%rax), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x6da5
movq %r12, %rdi
callq 0x13f9a
testl %eax, %eax
jne 0x6d9e
cmpw $0x0, 0x22(%r12)
movq %rbp, %rdx
leaq 0x19052(%rip), %rax     # 0x1fdc9
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 0x3190
movq 0x38(%r12), %r12
jmp 0x6d55
incq %r13
movq 0x8(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0x6d4d
cmpl $0x0, 0x28(%rbx)
jle 0x6dd9
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x6cc7
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x6dbd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e04
leaq 0x313b7(%rip), %rax     # 0x38228
testb $0x2, (%rax)
jne 0x6e7e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x18f3b(%rip), %rdi     # 0x1fdcb
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O1/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 0x3342f(%rip), %rbx     # 0x3a2d8
testq %rbx, %rbx
je 0x6ec5
movq 0x18(%rbx), %rax
movq %rax, 0x3341f(%rip)     # 0x3a2d8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x6ed2
movl $0x20, %edi
callq 0x61a1
movq %rax, %rbx
xorl %edi, %edi
callq 0x6773
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x705b
movl 0x8(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x8(%rdi)
movq 0x10(%rdi), %rax
cmpl %ecx, 0x4(%rax)
jl 0x705b
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x61a1
movq %rax, %rbx
callq 0x6ea1
movq %rax, (%rbx)
callq 0x6ea1
movq %rax, 0x8(%rbx)
callq 0x6ea1
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x711b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x70ce
movq (%r14), %rdi
callq 0x7291
movq 0x33215(%rip), %rax     # 0x3a2d8
movq %rax, 0x18(%r14)
movq %r14, 0x3320a(%rip)     # 0x3a2d8
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x70f1
movq (%r14), %rdi
callq 0x7291
movq 0x331f2(%rip), %rax     # 0x3a2d8
movq %rax, 0x18(%r14)
movq %r14, 0x331e7(%rip)     # 0x3a2d8
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x7114
movq (%rbx), %rdi
callq 0x7291
movq 0x331cf(%rip), %rax     # 0x3a2d8
movq %rax, 0x18(%rbx)
movq %rbx, 0x331c4(%rip)     # 0x3a2d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x713b
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_O1/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 0x71ab
movq (%rdi), %rax
testq %rax, %rax
je 0x7165
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x7165
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x7188
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x7188
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x71ab
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x71ab
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x330ec(%rip), %r14     # 0x3a2e0
testq %r14, %r14
je 0x720e
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x724c
movq 0x8(%r14), %r14
jmp 0x71f4
movl $0x10, %edi
callq 0x61a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x3309f(%rip), %rax     # 0x3a2e0
movq %rax, 0x8(%r14)
movq %r14, 0x33094(%rip)     # 0x3a2e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x33080(%rip), %r15     # 0x3a2e0
xorl %ebx, %ebx
testq %r15, %r15
je 0x7289
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3180
testl %eax, %eax
je 0x7284
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x726a
jmp 0x7289
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7365
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
jle 0x72c4
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7291
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x72ab
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x730c
cmpl $0x0, (%r14)
jle 0x72fa
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x7366
movq 0x8(%r14), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x72d6
movq 0x32faf(%rip), %rax     # 0x3a2b0
movq %rax, 0x10(%r14)
movq %r14, 0x32fa4(%rip)     # 0x3a2b0
movq 0x32fad(%rip), %rax     # 0x3a2c0
testq %rax, %rax
je 0x7325
movq 0x10(%rax), %rcx
movq %rcx, 0x32f9d(%rip)     # 0x3a2c0
jmp 0x732f
movl $0x18, %edi
callq 0x61a1
movl 0x2c(%rbx), %ecx
movl %ecx, (%rax)
movq 0x30(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x32f75(%rip), %rcx     # 0x3a2b8
movq %rcx, 0x10(%rax)
movq %rax, 0x32f6a(%rip)     # 0x3a2b8
movq 0x32f73(%rip), %rax     # 0x3a2c8
movq %rax, 0x10(%rbx)
movq %rbx, 0x32f68(%rip)     # 0x3a2c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x739d
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x7366
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x32f17(%rip), %rax     # 0x3a2a8
movq %rax, 0x38(%rbx)
movq %rbx, 0x32f0c(%rip)     # 0x3a2a8
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x308fb(%rip), %r14     # 0x381c8
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x6074
testq %rax, %rax
je 0x7911
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 0x3409
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7c97
movq 0x30411(%rip), %r12     # 0x37ff8
leaq 0x30582(%rip), %r13     # 0x38170
leaq 0x18e4c(%rip), %r15     # 0x20a41
leaq 0x2f8d4(%rip), %r14     # 0x374d0
movl (%rbx), %edi
cmpq $0x3, %rdi
je 0x7c6b
cmpl $0x4, %edi
jne 0x7c86
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
je 0x7c77
cmpl $0x5, %eax
je 0x7c71
cmpl $0x6, %eax
jne 0x7c8b
cmpl $0x4, %edi
ja 0x7c24
movq (%r14,%rdi,8), %r15
movq (%r12), %rbp
movq (%r13), %r14
movl %eax, %edi
callq 0x7b0d
movq 0x8(%rbx), %r9
movl 0x10(%rbx), %ecx
movl %ecx, (%rsp)
movq %rbp, %rdi
leaq 0x18a48(%rip), %rsi     # 0x2068f
movq %r14, %rdx
leaq 0x2f87f(%rip), %r14     # 0x374d0
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x3190
movq 0x48(%rbx), %rbx
leaq 0x18dd8(%rip), %r15     # 0x20a41
jmp 0x7c7b
cmpl $0x1, 0x1c(%rbx)
jne 0x7c7b
movq 0x48(%rbx), %rbx
jmp 0x7c7b
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x7bfc
jmp 0x7c97
cmpl $0x1, %edi
je 0x7c97
movq %rbx, %rsi
callq 0x3693
xorl %ebx, %ebx
jmp 0x7c7b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32516(%rip), %rbx     # 0x3a310
testq %rbx, %rbx
je 0x7e1e
movq 0x38(%rbx), %rax
movq %rax, 0x32506(%rip)     # 0x3a310
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x7e2b
movl $0x40, %edi
callq 0x61a1
movq %rax, %rbx
movq %r15, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3090
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xdb60
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x7e94
movl $0x60, %edi
xorl %esi, %esi
callq 0x5e90
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x7e9f
movq %r14, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x38(%rbx)
jmp 0x7ebb
movq 0x10(%rbx), %rdi
callq 0x61a0
jmp 0x7eb1
movq 0x10(%rbx), %rdi
callq 0x61a0
movq 0x30(%rbx), %rdi
callq 0xe054
movq %rbx, %rdi
callq 0x61a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7f00
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x7eed
callq 0x5f25
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x3241c(%rip), %rax     # 0x3a310
movq %rax, 0x38(%rbx)
movq %rbx, 0x32411(%rip)     # 0x3a310
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/treestk.c
// Function: top_of_stack
Stk_Item *
top_of_stack(TreeStack *treestk)
{
    if (is_empty(treestk))
        return((Stk_Item *) NULL);
    else
        return(treestk->top);
}

// Assembly:
testq %rdi, %rdi
je 0x7f8a
cmpq $0x0, (%rdi)
je 0x7f8a
movq (%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x802b
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x802b
movl %esi, %ebp
xorl %ebx, %ebx
callq 0xe45c
movq %r14, %rdi
callq 0x8032
testq %r14, %r14
je 0x801f
cmpq $0x0, (%r14)
setne %al
jmp 0x8021
xorl %eax, %eax
incl %ebx
testl %ebp, %ebp
je 0x802b
testb %al, %al
jne 0x8004
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c59d(%rip), %rax     # 0x3a340
movq 0x2c59e(%rip), %rcx     # 0x3a348
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %eax
addl 0x2c585(%rip), %eax     # 0x3a33c
movq 0x2c5aa(%rip), %rcx     # 0x3a368
movq 0x2c58b(%rip), %rdx     # 0x3a350
cmpq %rdx, %rcx
jae 0xde63
leaq 0x12ffb(%rip), %rsi     # 0x20dd0
leaq 0x1cfe4(%rip), %rdi     # 0x2adc0
leaq 0x17d5d(%rip), %r8      # 0x25b40
leaq 0x13476(%rip), %r9      # 0x21260
leaq 0x186ef(%rip), %r10     # 0x264e0
leaq 0x18218(%rip), %r11     # 0x26010
movslq %eax, %rbx
movzwl (%rsi,%rbx,2), %ebp
testw %bp, %bp
je 0xde11
movl %eax, 0x2c552(%rip)     # 0x3a35c
movq %rcx, 0x2c54f(%rip)     # 0x3a360
movzbl (%rcx), %r14d
testq %r14, %r14
je 0xde58
testw %bp, %bp
je 0xde2c
movl %eax, 0x2c537(%rip)     # 0x3a35c
movq %rcx, 0x2c534(%rip)     # 0x3a360
movswq (%r8,%rbx,2), %r15
addq %r14, %r15
movswl (%r9,%r15,2), %ebp
cmpl %ebp, %eax
je 0xde51
movswq (%r11,%rbx,2), %rbx
movswq (%r8,%rbx,2), %r15
addq %r14, %r15
cmpw (%r9,%r15,2), %bx
jne 0xde3d
movswl (%r10,%r15,2), %eax
jmp 0xde5b
movl (%rdi,%rbx,4), %eax
incq %rcx
cmpq %rdx, %rcx
jne 0xddf8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e682(%rip), %rbx     # 0x3ebc0
testq %rbx, %rbx
je 0x10555
movq 0x8(%r14), %rax
cmpq %rax, (%rbx)
je 0x105b0
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x10547
movl $0x20, %edi
callq 0x61a1
movq %rax, %rbx
cmpq $0x0, 0x8(%r14)
jne 0x10581
leaq 0x27c00(%rip), %rax     # 0x38170
movq (%rax), %rsi
leaq 0x1efc0(%rip), %rdi     # 0x2f53a
xorl %eax, %eax
callq 0x3100
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
movl 0x2e637(%rip), %eax     # 0x3ebc8
orl %eax, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x2e61d(%rip), %rax     # 0x3ebc0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2e612(%rip)     # 0x3ebc0
jmp 0x105b3
orl %ebp, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10b53
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x10b2e
movq 0x2e089(%rip), %rax     # 0x3ebd0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2e07e(%rip)     # 0x3ebd0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e053(%rip), %rax     # 0x3ebd0
testq %rax, %rax
je 0x10b99
movq 0x18(%rax), %rcx
movq %rcx, 0x2e043(%rip)     # 0x3ebd0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x10ba3
movl $0x20, %edi
callq 0x61a1
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
movq %rbx, 0x8(%rax)
movq 0x2e01f(%rip), %rcx     # 0x3ebd8
movq %rcx, 0x18(%rax)
movq %rax, 0x2e014(%rip)     # 0x3ebd8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x2dfff(%rip)     # 0x3ebe0
movl $0x20, %edi
callq 0x61a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %ebp, 0x8(%r14)
movq %r15, 0x10(%r14)
movq 0x2dfc4(%rip), %rax     # 0x3ebe0
movq %rax, 0x18(%r14)
movq %r14, 0x2dfb9(%rip)     # 0x3ebe0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2717b(%rip), %rbp     # 0x38228
leaq 0x1e588(%rip), %r12     # 0x2f63c
leaq 0x1e564(%rip), %r13     # 0x2f61f
cmpl $0x0, (%rbp)
je 0x11115
testq %r14, %r14
je 0x110fc
xorl %eax, %eax
movl $0x0, %r8d
testq %r15, %r15
je 0x110d6
movl (%r15), %r8d
testq %r15, %r15
je 0x110df
movl 0x1c(%r15), %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 0x1116c
movq 0x8(%r15), %rdx
movl 0x10(%r15), %ecx
movq %r12, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
testq %r15, %r15
je 0x1116c
movl (%r15), %eax
cmpl $0x4, %eax
je 0x11145
cmpl $0x2, %eax
jne 0x1116c
cmpl $0x1b, 0x1c(%r15)
jne 0x1116c
movq 0x50(%r15), %rax
testl %ebx, %ebx
jle 0x1113b
testq %rax, %rax
je 0x1117b
incl %ebx
movq %rax, %r15
jmp 0x110bb
movl 0x1c(%r15), %eax
cmpl $0x23, %eax
je 0x11153
cmpl $0x4, %eax
jne 0x1116c
movq 0x40(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0x11093
movq 0x48(%r15), %r15
jmp 0x110bb
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 0x1e4bf(%rip), %rdi     # 0x2f649
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_O1/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 0x1240e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x25fd7(%rip), %rax     # 0x38278
cmpl $0x0, (%rax)
je 0x12400
movq 0x38(%rsi), %r15
testq %r15, %r15
je 0x12400
movq 0x28(%r15), %rax
cmpb $0x2f, (%rax)
je 0x12400
movq %rdi, %rbx
cmpl $0x1, (%r15)
jne 0x122da
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
jmp 0x123ee
movq %r15, (%rsp)
movq 0x10(%r15), %rdi
callq 0x5e8a
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x25a0d(%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 0x12329
leaq (%r14,%r15), %rax
decq %rax
leaq 0x1(%rax), %r14
cmpb $0x20, 0x1(%rax)
movq %r14, %rax
je 0x1231c
incq %rbp
cmpq $0x3, %rbp
jne 0x122f3
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3270
testq %rax, %rax
je 0x123ad
movq %rax, %r12
movabsq $0x40100000200, %r13    # imm = 0x40100000200
movabsq $0x2800150100000200, %rbp # imm = 0x2800150100000200
movzbl -0x1(%r12), %eax
cmpq $0x2a, %rax
ja 0x12390
btq %rax, %r13
jae 0x12390
movq %r15, %rdi
callq 0x30d0
movzbl (%r12,%rax), %eax
cmpq $0x3d, %rax
ja 0x12390
btq %rax, %rbp
jb 0x123a8
incq %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3270
movq %rax, %r12
testq %rax, %rax
jne 0x12365
jmp 0x123ad
movb $0x0, (%r12)
movq %r14, %rdi
movl $0x3b, %esi
callq 0x30f0
testq %rax, %rax
movq (%rsp), %r15
jne 0x123e7
movq %r14, %rdi
movl $0x3d, %esi
callq 0x30f0
testq %rax, %rax
jne 0x123e7
movq %r14, %rdi
movl $0x2c, %esi
callq 0x30f0
testq %rax, %rax
je 0x123ee
leaq 0xda24(%rip), %r14      # 0x1fe12
cmpl $0x8, (%r15)
je 0x12400
movq %r14, %rdi
callq 0x12648
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_O1/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 0x12647
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x12627
cmpq %r14, (%rax)
je 0x12640
movq 0x8(%rax), %rax
jmp 0x12617
movl $0x10, %edi
callq 0x61a1
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_O1/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 0x4ddb9(%rip), %r15     # 0x60410
testq %r15, %r15
je 0x12674
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
testl %eax, %eax
je 0x126b5
movq 0x8(%r15), %r15
jmp 0x12657
movl $0x10, %edi
callq 0x61a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x4dd69(%rip), %rax     # 0x60410
movq %rax, 0x8(%r14)
movq %r14, 0x4dd5e(%rip)     # 0x60410
movq (%r14), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12734
movq %rdi, %rbx
testq %r15, %r15
je 0x1272f
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%r15), %rax
movq %rbx, %rcx
cmpq %rax, 0x8(%rcx)
jne 0x126f2
movl 0x4(%rcx), %edx
cmpl 0x4(%r15), %edx
je 0x1271a
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x126e3
movq 0x8(%r15), %rdi
movl 0x4(%r15), %esi
callq 0x10b6e
testq %r12, %r12
je 0x12714
movq %rax, 0x10(%r12)
jmp 0x12717
movq %rax, %r14
movq %rax, %r12
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x126dc
testq %r12, %r12
je 0x1272f
movq %rbx, 0x10(%r12)
jmp 0x12737
movq %rbx, %r14
jmp 0x12737
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_O1/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, 0x5c1ca(%rip)     # 0x6fe20
movb $0x0, 0x4c7c3(%rip)     # 0x60420
xorl %esi, %esi
callq 0x12900
leaq 0x245cd(%rip), %rax     # 0x38238
cmpl $0x0, (%rax)
jne 0x13c7f
leaq 0x4c7a9(%rip), %rdi     # 0x60420
movq %rbx, %rsi
callq 0x3140
movq $0x0, 0x5c196(%rip) # 0x6fe20
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bca8(%rip), %rsi     # 0x2f94f
callq 0x3210
testq %rax, %rax
je 0x13d4e
movq %rax, %r14
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x3170
testq %rax, %rax
je 0x13d46
movl $0x1, %ebp
leaq 0x1bf73(%rip), %r15     # 0x2fc4c
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3270
testq %rax, %rax
je 0x13d2f
movl $0x18, %edi
callq 0x61a1
movq %rax, %r13
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r13)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %ebp, 0x8(%r13)
movq 0x5c11c(%rip), %rax     # 0x6fe40
movq %rax, 0x10(%r13)
movq %r13, 0x5c111(%rip)     # 0x6fe40
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x3170
incl %ebp
testq %rax, %rax
jne 0x13cdc
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_O1/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 0x1bef2(%rip), %rdi     # 0x2fc5d
leaq 0x1bbdd(%rip), %rsi     # 0x2f94f
callq 0x3210
testq %rax, %rax
je 0x13d8f
movq %rax, %rbx
movq %rax, %rdi
callq 0x13df9
movq %rbx, %rdi
callq 0x30c0
leaq 0x24442(%rip), %r14     # 0x381d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13df1
callq 0x30d0
leaq 0xe(%rax), %rdi
callq 0x61a1
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x1bea1(%rip), %rsi     # 0x2fc5a
movq %rax, %rdi
xorl %eax, %eax
callq 0x3240
leaq 0x1bb85(%rip), %rsi     # 0x2f94f
movq %rbx, %rdi
callq 0x3210
testq %rax, %rax
je 0x13df1
movq %rax, %rbx
movq %rax, %rdi
callq 0x13df9
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_O1/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 0x13ee7
movq %rsp, %r14
movq 0x241c8(%rip), %rbp     # 0x37ff8
leaq 0x1bf5a(%rip), %r15     # 0x2fd91
movq %r14, %rdi
movl $0x9, %esi
callq 0x30f0
testq %rax, %rax
je 0x13ed4
movq %rax, %r13
movb $0x0, (%rax)
movl $0x18, %edi
callq 0x61a1
movq %rax, %r12
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
callq 0x3280
movq (%rax), %rcx
movsbq 0x1(%r13), %rdx
xorl %eax, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x13ea1
incq %r13
movq %r13, %rdi
callq 0x3220
movl %eax, 0x8(%r12)
movq 0x5bf93(%rip), %rax     # 0x6fe40
movq %rax, 0x10(%r12)
movq %r12, 0x5bf87(%rip)     # 0x6fe40
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x3170
testq %rax, %rax
jne 0x13e37
jmp 0x13ee7
movq (%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3190
jmp 0x13eb9
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5bf35(%rip), %rbx     # 0x6fe40
xorl %eax, %eax
testq %rbx, %rbx
je 0x13f7d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x2(%rdi), %r15
leaq 0x1bd48(%rip), %r12     # 0x2fc6a
movl 0x8(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl %ebp, %eax
setne %al
testb %al, %cl
jne 0x13f68
movq (%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3180
testl %eax, %eax
je 0x13f75
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3080
testl %eax, %eax
jne 0x13f68
movq %r13, %rdi
movq %r15, %rsi
callq 0x3180
testl %eax, %eax
je 0x13f75
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x13f22
xorl %eax, %eax
jmp 0x13f7d
incl 0xc(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1430e
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x142e9
movq 0x5bb4e(%rip), %rax     # 0x6fe50
movq %rax, 0x18(%rbx)
movq %rbx, 0x5bb43(%rip)     # 0x6fe50
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14333
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
jmp 0x14335
xorl %ebx, %ebx
movl $0x18, %edi
callq 0x61a1
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x61a1
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
testq %rbx, %rbx
je 0x1437c
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x3220
movl %eax, 0xc(%r15)
jmp 0x14384
movl $0x0, 0x8(%r15)
movq 0x5bacd(%rip), %rax     # 0x6fe58
movq %rax, 0x10(%r15)
movq %r15, 0x5bac2(%rip)     # 0x6fe58
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5ba6d(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x143ff
movq 0x18(%rax), %rcx
movq %rcx, 0x5ba5d(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x14409
movl $0x20, %edi
callq 0x61a1
movq %r14, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rbx), %ecx
movl %ecx, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5ba2d(%rip), %rax     # 0x6fe60
testq %rax, %rax
je 0x1444f
movq 0x18(%rax), %rcx
movq %rcx, 0x5ba1d(%rip)     # 0x6fe60
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x14459
movl $0x20, %edi
callq 0x61a1
movq %rbx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b9ff(%rip), %r14     # 0x6fe68
testq %r14, %r14
je 0x14490
movq %rdi, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x1448b
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x14471
jmp 0x14490
orb $0x4, 0x42(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x144c6
movq (%r14), %rcx
cmpq %rcx, (%rax)
jne 0x144bd
movl 0x10(%rax), %edx
cmpl 0x10(%r14), %edx
je 0x1451f
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x144af
movq (%r14), %r15
movq 0x5b980(%rip), %rax     # 0x6fe50
testq %rax, %rax
je 0x144ec
movq 0x18(%rax), %rcx
movq %rcx, 0x5b970(%rip)     # 0x6fe50
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x144f6
movl $0x20, %edi
callq 0x61a1
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 0x14519