LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x33727(%rip), %r14     # 0x392f0
movq (%r14), %r14
testq %r14, %r14
je 0x5be6
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3190
addq $0x8, %r14
testl %eax, %eax
jne 0x5bc9
jmp 0x5c22
pushq $0x10
popq %rdi
callq 0x4da5
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x336d9(%rip), %rax     # 0x392f0
movq %rax, 0x8(%r14)
movq %r14, 0x336ce(%rip)     # 0x392f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r14
leaq 0x336b7(%rip), %r15     # 0x392f0
pushq $0x1
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x5c59
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3190
addq $0x8, %r15
testl %eax, %eax
jne 0x5c3c
jmp 0x5c5b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5d6c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jge 0x5cd4
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x5ca5
incq %r14
jmp 0x5cb9
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x5d15
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x5d03
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x5d6d
movq 0x8(%r14), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x5ce0
movq 0x335b6(%rip), %rax     # 0x392c0
movq %rax, 0x10(%r14)
movq %r14, 0x335ab(%rip)     # 0x392c0
movq 0x335b4(%rip), %rax     # 0x392d0
testq %rax, %rax
je 0x5d2e
movq 0x10(%rax), %rcx
movq %rcx, 0x335a4(%rip)     # 0x392d0
jmp 0x5d36
pushq $0x18
popq %rdi
callq 0x4da5
movl 0x2c(%rbx), %ecx
movl %ecx, (%rax)
movq 0x30(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x3357e(%rip), %rcx     # 0x392c8
movq %rcx, 0x10(%rax)
movq %rax, 0x33573(%rip)     # 0x392c8
movq 0x3357c(%rip), %rax     # 0x392d8
movq %rax, 0x10(%rbx)
movq %rbx, 0x33571(%rip)     # 0x392d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5da5
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x5d6d
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x30(%rbx)
movups %xmm0, (%rbx)
movq 0x3351f(%rip), %rax     # 0x392b8
movq %rax, 0x38(%rbx)
movq %rbx, 0x33514(%rip)     # 0x392b8
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x30ebb(%rip), %r14     # 0x371d8
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x4ca3
testq %rax, %rax
je 0x6361
movl $0x4, (%rax)
movl %ebx, 0x1c(%rax)
andq $0x0, 0x28(%rax)
movq (%r14), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x20(%rcx), %ecx
movl %ecx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
andq $0x0, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30c90(%rip), %rax     # 0x36ff8
movq (%rax), %rsi
leaq 0x18122(%rip), %rdi     # 0x1e494
callq 0x3140
pushq $0x1
popq %rdi
callq 0x3270
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdi, %r12
movq 0x30804(%rip), %rbx     # 0x36ff8
leaq 0x30985(%rip), %rbp     # 0x37180
pushq $0x4
popq %rax
leaq 0x17e7e(%rip), %r14     # 0x1e683
leaq 0x17ec2(%rip), %r15     # 0x1e6ce
testq %r12, %r12
je 0x68f4
movl (%r12), %edi
cmpl $0x3, %edi
jne 0x6828
cmpl $0x1, 0x1c(%r12)
jne 0x680c
jmp 0x6847
cmpl $0x1, %edi
je 0x68f4
cmpl $0x4, %edi
jne 0x6855
movl 0x1c(%r12), %r13d
cmpl $0x2, %r13d
je 0x684e
cmpl $0x5, %r13d
jne 0x685c
movq 0x48(%r12), %r12
jmp 0x680c
movq 0x40(%r12), %r12
jmp 0x680c
movl 0x1c(%r12), %r13d
jmp 0x68ae
cmpl $0x6, %r13d
jne 0x68ae
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rbp), %r13
movl %eax, %edi
callq 0x655a
movq %rax, 0x8(%rsp)
pushq $0x6
popq %rdi
callq 0x66b2
movq 0x8(%r12), %r9
movl 0x10(%r12), %ecx
movl %ecx, (%rsp)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x31a0
pushq $0x4
popq %rax
jmp 0x6847
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq (%rbp), %rax
movq %rax, 0x10(%rsp)
callq 0x655a
movq %rax, %r12
movl %r13d, %edi
callq 0x66b2
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x31a0
pushq $0x4
popq %rax
xorl %r12d, %r12d
jmp 0x680c
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x327f6(%rip), %rbx     # 0x39320
testq %rbx, %rbx
je 0x6b4e
movq 0x38(%rbx), %rax
movq %rax, 0x327e6(%rip)     # 0x39320
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x6b59
pushq $0x40
popq %rdi
callq 0x4da5
movq %rax, %rbx
movq %r15, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3090
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xbfda
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x6bbd
pushq $0x60
popq %rdi
xorl %esi, %esi
callq 0x4acc
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6bc8
movq %r14, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
andq $0x0, (%rbx)
andq $0x0, 0x38(%rbx)
jmp 0x6be4
movq 0x10(%rbx), %rdi
callq 0x4da4
jmp 0x6bda
movq 0x10(%rbx), %rdi
callq 0x4da4
movq 0x30(%rbx), %rdi
callq 0xc51f
movq %rbx, %rdi
callq 0x4da4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6c2a
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6c17
callq 0x4b57
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
movq 0x32702(%rip), %rax     # 0x39320
movq %rax, 0x38(%rbx)
movq %rbx, 0x326f7(%rip)     # 0x39320
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d39
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x6d39
movl %esi, %ebp
xorl %ebx, %ebx
callq 0xc9b0
incl %ebx
movq %r14, %rdi
callq 0x6d40
testl %ebp, %ebp
je 0x6d39
cmpq $0x0, (%r14)
jne 0x6d20
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq 0x2d02b(%rip), %rax     # 0x39350
movq 0x2d02c(%rip), %rcx     # 0x39358
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %eax
addl 0x2d013(%rip), %eax     # 0x3934c
movq 0x2d038(%rip), %rcx     # 0x39378
movq 0x2d019(%rip), %rdx     # 0x39360
leaq 0x12a72(%rip), %rsi     # 0x1edc0
leaq 0x1ca5b(%rip), %rdi     # 0x28db0
leaq 0x177d4(%rip), %r8      # 0x23b30
leaq 0x12eed(%rip), %r9      # 0x1f250
leaq 0x18166(%rip), %r10     # 0x244d0
leaq 0x17c8f(%rip), %r11     # 0x24000
cmpq %rdx, %rcx
jae 0xc3c2
movslq %eax, %rbx
cmpw $0x0, (%rsi,%rbx,2)
je 0xc38d
movl %eax, 0x2cfe6(%rip)     # 0x3936c
movq %rcx, 0x2cfe3(%rip)     # 0x39370
movb (%rcx), %bpl
testb %bpl, %bpl
je 0xc3ba
movzbl %bpl, %ebx
cltq
movswq (%r8,%rax,2), %r14
addq %rbx, %r14
movswl (%r9,%r14,2), %ebp
cmpl %ebp, %eax
je 0xc3b3
movswl (%r11,%rax,2), %eax
jmp 0xc399
movswl (%r10,%r14,2), %eax
jmp 0xc3bd
movl (%rdi,%rbx,4), %eax
incq %rcx
jmp 0xc371
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x2ef62(%rip), %rbx     # 0x3dbd0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xec85
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
je 0xecdd
addq $0x18, %rbx
jmp 0xec6e
pushq $0x20
popq %rdi
callq 0x4da5
movq %rax, %rbx
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xecb5
leaq 0x284e0(%rip), %rax     # 0x37180
movq (%rax), %rsi
leaq 0x1e87c(%rip), %rdi     # 0x2d526
xorl %eax, %eax
callq 0x3100
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
movl 0x2ef17(%rip), %eax     # 0x3dbd8
orl %eax, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
movq 0x2ef00(%rip), %rax     # 0x3dbd0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2eef5(%rip)     # 0x3dbd0
jmp 0xece0
orl %ebp, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf21b
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xf1f6
movq 0x2e9d1(%rip), %rax     # 0x3dbe0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2e9c6(%rip)     # 0x3dbe0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e99e(%rip), %rax     # 0x3dbe0
testq %rax, %rax
je 0xf25e
movq 0x18(%rax), %rcx
movq %rcx, 0x2e98e(%rip)     # 0x3dbe0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0xf266
pushq $0x20
popq %rdi
callq 0x4da5
andq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
movq %rbx, 0x8(%rax)
movq 0x2e96f(%rip), %rcx     # 0x3dbe8
movq %rcx, 0x18(%rax)
movq %rax, 0x2e964(%rip)     # 0x3dbe8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
andq $0x0, 0x2e954(%rip)     # 0x3dbf0
pushq $0x20
popq %rdi
callq 0x4da5
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %ebp, 0x8(%r14)
andq $0x0, 0x10(%r14)
movq 0x2e91a(%rip), %rax     # 0x3dbf0
movq %rax, 0x18(%r14)
movq %r14, 0x2e90f(%rip)     # 0x3dbf0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27bc3(%rip), %r13     # 0x37238
leaq 0x1dfac(%rip), %r12     # 0x2d628
pushq $0x2
popq %rbp
cmpl $0x0, (%r13)
je 0xf699
testq %r14, %r14
je 0xf6c6
testq %r15, %r15
je 0xf6a3
movl (%r15), %r8d
movl 0x1c(%r15), %eax
jmp 0xf6a8
testq %r15, %r15
jne 0xf6df
jmp 0xf731
xorl %r8d, %r8d
xorl %eax, %eax
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movl %eax, (%rsp)
leaq 0x1df51(%rip), %rdi     # 0x2d60b
movl %ebx, %esi
movl %ebp, %r9d
xorl %eax, %eax
callq 0x3100
testq %r15, %r15
je 0xf731
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 0xf70a
cmpl $0x2, %eax
jne 0xf731
cmpl $0x1b, 0x1c(%r15)
jne 0xf731
movq 0x50(%r15), %rax
testl %ebx, %ebx
jle 0xf700
testq %rax, %rax
je 0xf740
incl %ebx
movq %rax, %r15
jmp 0xf67f
movl 0x1c(%r15), %eax
cmpl $0x23, %eax
je 0xf718
cmpl $0x4, %eax
jne 0xf731
movq 0x40(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0xf65b
movq 0x48(%r15), %r15
jmp 0xf67f
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 0x1dee6(%rip), %rdi     # 0x2d635
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_O2/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 0x10cac
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rbx
movq %rbx, %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x10c93
leaq 0x8(%rcx), %rax
cmpq %r14, (%rcx)
jne 0x10c80
jmp 0x10ca5
callq 0x10db1
movq %r14, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x4e764(%rip), %r15     # 0x5f420
movq (%r15), %r15
testq %r15, %r15
je 0x10cdc
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
addq $0x8, %r15
testl %eax, %eax
jne 0x10cbc
jmp 0x10d1b
pushq $0x10
popq %rdi
callq 0x4da5
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq 0x4e713(%rip), %rax     # 0x5f420
movq %rax, 0x8(%r14)
movq %r14, 0x4e708(%rip)     # 0x5f420
movq (%r14), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10d9f
movq %rdi, %rbx
testq %r15, %r15
je 0x10d9a
xorl %r14d, %r14d
xorl %r12d, %r12d
testq %r15, %r15
je 0x10d8e
movq 0x8(%r15), %rdi
movq %rbx, %rax
testq %rax, %rax
je 0x10d68
cmpq %rdi, 0x8(%rax)
jne 0x10d62
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
je 0x10d82
movq 0x10(%rax), %rax
jmp 0x10d4e
movl 0x4(%r15), %esi
callq 0xf233
testq %r12, %r12
je 0x10d7d
movq %rax, 0x10(%r12)
jmp 0x10d85
movq %rax, %r14
jmp 0x10d85
movq %r12, %rax
movq 0x10(%r15), %r15
movq %rax, %r12
jmp 0x10d42
testq %r12, %r12
je 0x10d9a
movq %rbx, 0x10(%r12)
jmp 0x10da2
movq %rbx, %r14
jmp 0x10da2
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x5cf3c(%rip)     # 0x6ee30
movb $0x0, 0x4d535(%rip)     # 0x5f430
xorl %esi, %esi
callq 0x10f68
leaq 0x2533f(%rip), %rax     # 0x37248
cmpl $0x0, (%rax)
jne 0x11f1d
leaq 0x4d51b(%rip), %rdi     # 0x5f430
movq %rbx, %rsi
callq 0x3140
andq $0x0, 0x5cf0b(%rip)     # 0x6ee30
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b97c(%rip), %rsi     # 0x2d93b
callq 0x3230
testq %rax, %rax
je 0x12051
movq %rax, %r14
pushq $0x1
popq %r13
movq %rsp, %r15
leaq 0x1bc82(%rip), %r12     # 0x2dc60
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x3170
testq %rax, %rax
je 0x12049
movq %r15, %rdi
movq %r12, %rsi
callq 0x3290
testq %rax, %rax
je 0x12044
pushq $0x18
popq %rdi
callq 0x4da5
movq %rax, %rbp
movq %rbx, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%rbp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movl %r13d, 0x8(%rbp)
movq 0x5ce17(%rip), %rax     # 0x6ee50
movq %rax, 0x10(%rbp)
movq %rbp, 0x5ce0c(%rip)     # 0x6ee50
incl %r13d
jmp 0x11fde
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_O2/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 0x1bc03(%rip), %rdi     # 0x2dc71
leaq 0x1b8c6(%rip), %rsi     # 0x2d93b
callq 0x3230
testq %rax, %rax
je 0x12092
movq %rax, %rbx
movq %rax, %rdi
callq 0x120fc
movq %rbx, %rdi
callq 0x30c0
leaq 0x2514f(%rip), %r14     # 0x371e8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x120f4
callq 0x30d0
leaq 0xe(%rax), %rdi
callq 0x4da5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x1bbb2(%rip), %rsi     # 0x2dc6e
movq %rax, %rdi
xorl %eax, %eax
callq 0x3260
leaq 0x1b86e(%rip), %rsi     # 0x2d93b
movq %rbx, %rdi
callq 0x3230
testq %rax, %rax
je 0x120f4
movq %rax, %rbx
movq %rax, %rdi
callq 0x120fc
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_O2/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, %r14
pushq $0x9
popq %rbp
pushq $0x18
popq %r12
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x3170
testq %rax, %rax
je 0x121cf
movq %r14, %rdi
movl %ebp, %esi
callq 0x30f0
testq %rax, %rax
je 0x121af
movq %rax, %r15
movb $0x0, (%rax)
movq %r12, %rdi
callq 0x4da5
movq %rax, %r13
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%r13)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
callq 0x32a0
movq (%rax), %rcx
movsbq 0x1(%r15), %rdx
xorl %eax, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x12194
incq %r15
movq %r15, %rdi
callq 0x3240
movl %eax, 0x8(%r13)
movq 0x5ccb1(%rip), %rax     # 0x6ee50
movq %rax, 0x10(%r13)
movq %r13, 0x5cca6(%rip)     # 0x6ee50
jmp 0x1211a
movq 0x24e42(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
leaq 0x1bbe2(%rip), %rsi     # 0x2dda2
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x1211a
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2(%rdi), %r15
leaq 0x5cc56(%rip), %r13     # 0x6ee50
movq (%r13), %r13
testq %r13, %r13
je 0x1224a
movl 0x8(%r13), %eax
testl %eax, %eax
setne %cl
cmpl %ebx, %eax
setne %al
testb %al, %cl
jne 0x12244
movq (%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3190
testl %eax, %eax
je 0x1224e
cmpb $0x2e, (%r14)
jne 0x12244
cmpb $0x2f, 0x1(%r14)
jne 0x12244
movq %r12, %rdi
movq %r15, %rsi
callq 0x3190
testl %eax, %eax
je 0x1224e
addq $0x10, %r13
jmp 0x121fa
xorl %eax, %eax
jmp 0x12255
incl 0xc(%r13)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x125ec
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x125c7
movq 0x5c880(%rip), %rax     # 0x6ee60
movq %rax, 0x18(%rbx)
movq %rbx, 0x5c875(%rip)     # 0x6ee60
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3a
popq %rsi
callq 0x30f0
testq %rax, %rax
je 0x1260f
movq %rax, %rbx
movb $0x0, (%rax)
incq %rbx
jmp 0x12611
xorl %ebx, %ebx
pushq $0x18
popq %rdi
callq 0x4da5
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
leaq 0x1(%rax), %rdi
callq 0x4da5
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3090
testq %rbx, %rbx
je 0x12656
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x3240
movl %eax, 0xc(%r15)
jmp 0x1265b
andl $0x0, 0x8(%r15)
movq 0x5c806(%rip), %rax     # 0x6ee68
movq %rax, 0x10(%r15)
movq %r15, 0x5c7fb(%rip)     # 0x6ee68
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12673
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5c7a0(%rip), %rax     # 0x6ee70
testq %rax, %rax
je 0x126ec
movq 0x18(%rax), %rcx
movq %rcx, 0x5c790(%rip)     # 0x6ee70
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x126f4
pushq $0x20
popq %rdi
callq 0x4da5
movq %rbx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
leaq 0x5c771(%rip), %r14     # 0x6ee78
movq (%r14), %r14
testq %r14, %r14
je 0x12729
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3190
testl %eax, %eax
je 0x12724
addq $0x48, %r14
jmp 0x12707
orb $0x4, 0x42(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rbx
movq %rbx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x12761
movq (%rax), %rcx
cmpq (%r14), %rcx
jne 0x1275b
movl 0x10(%rax), %ecx
cmpl 0x10(%r14), %ecx
je 0x12787
addq $0x18, %rax
jmp 0x12742
movq (%r14), %rdi
callq 0x12673
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rbx)
pushq $0x1
popq %rax
jmp 0x12789
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x127e0
cmpl $0x30, 0x1c(%rdi)
jne 0x127e0
cmpl $0x102, 0x18(%rsi)      # imm = 0x102
jne 0x127e0
movq 0x40(%rsi), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x40(%rdi)
je 0x127ca
leaq 0x1b5c1(%rip), %rsi     # 0x2dd89
jmp 0x127d1
leaq 0x1b5c0(%rip), %rsi     # 0x2dd91
movq %rax, %rdi
callq 0x3190
testl %eax, %eax
jne 0x127e0
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: zero_test
int
zero_test(treenode *ex)	/* true if condition ex is a simple comparison against 0 */
{
	if (!ex) return 0;

	if (ex->hdr.type == TN_IDENT)
		return 1;	/* s */

	if (ex->hdr.type != TN_EXPR
	||  ex->hdr.tok == AND
	||  ex->hdr.tok == OR)
		return 0;

	if (ex->hdr.tok == NOT
	&&  ex->lnode == ZT)
	{	if (ex->rnode->hdr.type == TN_IDENT)
			return 1;	/* !s */

		if (ex->rnode->hdr.type == TN_EXPR
		&&  ex->rnode->hdr.tok == NOT_EQ
		&&  ex->rnode->lnode
		&&  ex->rnode->lnode->hdr.type == TN_IDENT
		&&  is_zero_val(ex->rnode->rnode))
			return 1;	/* !(s != 0) */

		if (ex->rnode->hdr.type == TN_EXPR
		&&  ex->rnode->hdr.tok == EQUAL
		&&  ex->rnode->lnode
		&&  ex->rnode->lnode->hdr.type == TN_IDENT
		&&  is_zero_val(ex->rnode->rnode))
			return 1;	/* !(s == 0) */
	} else {
		if ((ex->hdr.tok == EQUAL || ex->hdr.tok == NOT_EQ)
		&&  ex->lnode
		&&  ex->lnode->hdr.type == TN_IDENT
		&&  is_zero_val(ex->rnode))
			return 1;	/* (s == 0) or (s != 0) */
	}
	return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x12891
pushq %rbx
movl 0x1c(%rdi), %ecx
pushq $0x1
popq %rbx
cmpl $0x2d, %ecx
je 0x1286a
cmpl $0x28, %ecx
jne 0x12890
movl 0x18(%rdi), %ecx
leal -0x150(%rcx), %edx
cmpl $0x2, %edx
jb 0x12890
cmpl $0x137, %ecx            # imm = 0x137
je 0x1286e
cmpl $0x13a, %ecx            # imm = 0x13A
je 0x1286e
cmpl $0x162, %ecx            # imm = 0x162
jne 0x1288e
cmpq $0x0, 0x40(%rdi)
jne 0x1288e
movq 0x48(%rdi), %rax
movl 0x1c(%rax), %ecx
cmpl $0x2d, %ecx
je 0x1286a
cmpl $0x28, %ecx
jne 0x1288e
movl 0x18(%rax), %ecx
cmpl $0x137, %ecx            # imm = 0x137
je 0x12855
cmpl $0x13a, %ecx            # imm = 0x13A
jne 0x1288e
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x1288e
cmpl $0x2d, 0x1c(%rcx)
jne 0x1288e
movq 0x48(%rax), %rdi
jmp 0x12881
movl %ebx, %eax
jmp 0x12890
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1288e
cmpl $0x2d, 0x1c(%rax)
jne 0x1288e
movq 0x48(%rdi), %rdi
callq 0x12892
movl %eax, %ecx
movl %ebx, %eax
testl %ecx, %ecx
jne 0x12890
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: is_zero_val
static int
is_zero_val(treenode *n)
{
	if (!n) return 0;

	if (n->hdr.type == TN_CAST)
		return is_zero_val(n->rnode);

	return (n->hdr.type == TN_INT
		&&  ((leafnode *)n)->data.ival == 0);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x128b5
movl 0x1c(%rdi), %ecx
cmpl $0x1a, %ecx
jne 0x128a7
movq 0x48(%rdi), %rdi
jmp 0x12894
cmpl $0x30, %ecx
jne 0x128b5
xorl %eax, %eax
cmpl $0x0, 0x40(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_graph
static Graphs *
rel_graph(Graphs *g)
{
	if (g)
	{	rel_graph(g->nxt);
		g->all = rel_state(g->all);
		g->fcalls  = rel_symext(g->fcalls);
		g->suspect = rel_symext(g->suspect);
		g->def_use = rel_symref(g->def_use);
		g->locs = rel_symref(g->locs);

		g->nxt = freegraph;
		freegraph = g;
	}
	return (Graphs *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x13b7d
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x13b12
movq 0x10(%rbx), %rdi
callq 0x14a00
andq $0x0, 0x10(%rbx)
movq 0x28(%rbx), %rdi
callq 0x14a6c
andq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x14a6c
andq $0x0, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x20(%rbx)
movq 0x5b357(%rip), %rax     # 0x6eec8
movq %rax, 0x48(%rbx)
movq %rbx, 0x5b34c(%rip)     # 0x6eec8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_label
static LNode *
rel_label(LNode *n)
{
	if (n)
	{	rel_label(n->nxt);
		n->nxt = freelabels;
		freelabels = n;
	}
	return (LNode *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x13ba3
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x13b7e
movq 0x5b351(%rip), %rax     # 0x6eee8
movq %rax, 0x18(%rbx)
movq %rbx, 0x5b346(%rip)     # 0x6eee8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_sframe
static Stack *
rel_sframe(Stack *f)
{
	if (f)
	{	rel_sframe(f->nxt);
		f->nxt = fol;
		fol = f;
	}
	return (Stack *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x13bc9
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x13ba4
movq 0x5b333(%rip), %rax     # 0x6eef0
movq %rax, 0x10(%rbx)
movq %rbx, 0x5b328(%rip)     # 0x6eef0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_state
static State *
rel_state(State *s)
{
	if (s)
	{	rel_state(s->all);
		s->gi = rel_symref(s->gi);
		s->il = rel_symref(s->il);
		s->snapshot = rel_symref(s->snapshot);
		s->succ = rel_trans(s->succ);
		s->direct = rel_trans(s->direct);

		s->all = freestate;
		freestate = s;
	}
	return (State *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x14a6b
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x14a00
movq 0x10(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x18(%rbx)
movq 0x8(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x8(%rbx)
movq 0x50(%rbx), %rdi
callq 0x14ab8
andq $0x0, 0x50(%rbx)
movq 0x58(%rbx), %rdi
callq 0x14ab8
andq $0x0, 0x58(%rbx)
movq 0x5a471(%rip), %rax     # 0x6eed0
movq %rax, 0x68(%rbx)
movq %rbx, 0x5a466(%rip)     # 0x6eed0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_symext
static SymExt *
rel_symext(SymExt *s)
{
	if (s)
	{	rel_symext(s->nxt);
		s->nxt = freesymext;
		freesymext = s;
	}
	return (SymExt *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x14a91
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x14a6c
movq 0x5a3eb(%rip), %rax     # 0x6ee70
movq %rax, 0x18(%rbx)
movq %rbx, 0x5a3e0(%rip)     # 0x6ee70
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_symref
static SymRef *
rel_symref(SymRef *s)
{
	if (s)
	{	rel_symref(s->nxt);
		s->nxt = freesymref;
		freesymref = s;
	}
	return (SymRef *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x14ab7
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x14a92
movq 0x5a435(%rip), %rax     # 0x6eee0
movq %rax, 0x18(%rbx)
movq %rbx, 0x5a42a(%rip)     # 0x6eee0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: rel_trans
static Trans *
rel_trans(Trans *t)
{
	if (t)
	{	rel_trans(t->nxt);
		t->knz = rel_symref(t->knz);
		t->nxt = freetrans;
		freetrans = t;
	}

	return (Trans *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x14aeb
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x14ab8
movq 0x8(%rbx), %rdi
callq 0x14a92
andq $0x0, 0x8(%rbx)
movq 0x5a3f9(%rip), %rax     # 0x6eed8
movq %rax, 0x18(%rbx)
movq %rbx, 0x5a3ee(%rip)     # 0x6eed8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: create_state
static State *
create_state(Graphs *g)
{	State *s;

	if (freestate)
	{	s = freestate;
		freestate = s->all;
		memset(s, 0, sizeof(State));
	} else
		s = (State *) emalloc(sizeof(State));

	s->all = g->all;
	g->all = s;
	return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x5a3d9(%rip), %rax     # 0x6eed0
testq %rax, %rax
je 0x14b27
movq 0x68(%rax), %rcx
movq %rcx, 0x5a3c9(%rip)     # 0x6eed0
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x14b2f
pushq $0x70
popq %rdi
callq 0x4da5
movq 0x10(%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: get_trans
static Trans *
get_trans(void)
{	Trans *t;

	if (freetrans)
	{	t = freetrans;
		freetrans = t->nxt;
		memset(t, 0, sizeof(Trans));
	} else
		t = (Trans *) emalloc(sizeof(Trans));
	return t;
}

// Assembly:
movq 0x5a394(%rip), %rax     # 0x6eed8
testq %rax, %rax
je 0x14b5f
movq 0x18(%rax), %rcx
movq %rcx, 0x5a384(%rip)     # 0x6eed8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
retq
pushq $0x20
popq %rdi
jmp 0x4da5
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: mk_goto_node
static treenode *
mk_goto_node(leafnode *ident)
{	treenode *t;

	t = (treenode *) emalloc(sizeof(treenode));
	t->hdr.which = NODE_T;
	t->hdr.type = TN_JUMP;
	t->hdr.tok = GOTO;
	t->hdr.fnm = "UNO2";
	t->lnode = (treenode *) ident;

	return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x4da5
movl $0x4, (%rax)
movabsq $0x1d0000011c, %rcx     # imm = 0x1D0000011C
movq %rcx, 0x18(%rax)
leaq 0x192bd(%rip), %rcx     # 0x2de4b
movq %rcx, 0x8(%rax)
movq %rbx, 0x40(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: mk_label_node
static treenode *
mk_label_node(leafnode *ident, treenode *n, char *s)
{	treenode *t;

	t = (treenode *) emalloc(sizeof(treenode));
	t->hdr.which = NODE_T;
	t->hdr.type = TN_LABEL;	/* just a place holder */
	t->hdr.tok = COLON;

	t->hdr.fnm = (char *) emalloc(strlen(n->hdr.fnm)+strlen(" after ''")+strlen(s)+1);
	sprintf(t->hdr.fnm, "%s after '%s'", n->hdr.fnm, s);

	t->hdr.line = n->hdr.line;
	t->lnode = (treenode *) ident;
	/* t->rnode -- normally points to stmnt labeled */
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x4da5
movq %rax, %r12
movl $0x4, (%rax)
movabsq $0x220000014e, %rax     # imm = 0x220000014E
movq %rax, 0x18(%r12)
movq 0x8(%r14), %rdi
callq 0x30d0
movq %rax, %r13
movq %r15, %rdi
callq 0x30d0
leaq (%rax,%r13), %rdi
addq $0xa, %rdi
callq 0x4da5
movq %rax, 0x8(%r12)
movq 0x8(%r14), %rdx
leaq 0x19255(%rip), %rsi     # 0x2de50
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x3260
movl 0x10(%r14), %eax
movl %eax, 0x10(%r12)
movq %rbx, 0x40(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_push_start
static void
lts_push_start(treenode *n)
{	Stack *f;

	f = lts_new_stack();
	f->n = n;
	f->nxt = sol;
	sol = f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x14d2e
movq %rbx, (%rax)
movq 0x5a2ca(%rip), %rcx     # 0x6ef00
movq %rcx, 0x10(%rax)
movq %rax, 0x5a2bf(%rip)     # 0x6ef00
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_push_end
static void
lts_push_end(treenode *n)
{	Stack *f;

	f = lts_new_stack();
	f->status = 1;
	f->n = n;
	f->nxt = eol;
	eol = f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x14d2e
movl $0x1, 0x8(%rax)
movq %rbx, (%rax)
movq 0x5a2ab(%rip), %rcx     # 0x6ef08
movq %rcx, 0x10(%rax)
movq %rax, 0x5a2a0(%rip)     # 0x6ef08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: add_seq
static State *
add_seq(State *cur, treenode *n)
{	State *s;

	if (!cur) return cur;

	uno_assert((n != NULL), "bad call of add_seq");

	s = create_state(curgraph);
	s->n = n;

	cur->nxt = s;
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x14ca9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %edi, %edi
testq %rsi, %rsi
setne %dil
leaq 0x191fd(%rip), %rsi     # 0x2de86
callq 0x1225f
movq 0x5a1c3(%rip), %rdi     # 0x6ee58
callq 0x14aec
movq %r14, (%rax)
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_pop_start
static void
lts_pop_start(void)
{	Stack *f;

	uno_assert((sol != NULL), "start stack underflow");
	f = sol;
	sol = sol->nxt;

	f->nxt = fol;
	fol = f;
}

// Assembly:
pushq %rax
xorl %edi, %edi
cmpq $0x0, 0x5a249(%rip)     # 0x6ef00
setne %dil
leaq 0x191d8(%rip), %rsi     # 0x2de9a
callq 0x1225f
movq 0x5a232(%rip), %rax     # 0x6ef00
movq 0x10(%rax), %rcx
movq %rcx, 0x5a227(%rip)     # 0x6ef00
movq 0x5a210(%rip), %rcx     # 0x6eef0
movq %rcx, 0x10(%rax)
movq %rax, 0x5a205(%rip)     # 0x6eef0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: lts_pop_end
static void
lts_pop_end(void)
{	Stack *f;

	uno_assert((eol != NULL), "end stack underflow");

	f = eol;
	eol = eol->nxt;

	f->nxt = fol;
	fol = f;
}

// Assembly:
pushq %rax
xorl %edi, %edi
cmpq $0x0, 0x5a210(%rip)     # 0x6ef08
setne %dil
leaq 0x191ad(%rip), %rsi     # 0x2deb0
callq 0x1225f
movq 0x5a1f9(%rip), %rax     # 0x6ef08
movq 0x10(%rax), %rcx
movq %rcx, 0x5a1ee(%rip)     # 0x6ef08
movq 0x5a1cf(%rip), %rcx     # 0x6eef0
movq %rcx, 0x10(%rax)
movq %rax, 0x5a1c4(%rip)     # 0x6eef0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: record_label
static void
record_label(treenode *s, State *n)	/* associate symentry with state in cfg */
{	LNode *ln;
	leafnode *x = (leafnode *) s;

	uno_assert((int) (x && n), "bad call to record_label");

	if (freelabels)
	{	ln = freelabels;
		freelabels = ln->nxt;
		memset(ln, 0, sizeof(LNode));
	} else
		ln = (LNode *) emalloc(sizeof(LNode));
	ln->s = x->data.sval->str;
	ln->f = curgraph?curgraph->fctnm:"_noname_";
	ln->n = n;
	ln->nxt = lnodes;
	lnodes = ln;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
movzbl %cl, %edi
leaq 0x1914b(%rip), %rsi     # 0x2df0b
callq 0x1225f
movq 0x5a11c(%rip), %rax     # 0x6eee8
testq %rax, %rax
je 0x14de8
movq 0x18(%rax), %rcx
movq %rcx, 0x5a10c(%rip)     # 0x6eee8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x14df0
pushq $0x20
popq %rdi
callq 0x4da5
movq 0x40(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq 0x5a056(%rip), %rcx     # 0x6ee58
testq %rcx, %rcx
je 0x14e0c
movq (%rcx), %rcx
jmp 0x14e13
leaq 0x19111(%rip), %rcx     # 0x2df24
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0x5a07e(%rip), %rcx     # 0x6eea0
movq %rcx, 0x18(%rax)
movq %rax, 0x5a073(%rip)     # 0x6eea0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_lts.c
// Function: want_break
static void
want_break(treenode *n)
{	Stack *f;
	uno_assert((eol != NULL), "case outside switch");

	if (lintlike && !eol->status)	/* uno cannot tell that eol is nonzero */
	{	if (fol)
		{	f = fol;
			fol = fol->nxt;
			memset(f, 0, sizeof(Stack));
		} else
			f = (Stack *) emalloc(sizeof(Stack));
		f->n = n;
		f->nxt = fallthru;
		fallthru = f;
	}
	eol->status = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
cmpq $0x0, 0x5a0c5(%rip)     # 0x6ef08
setne %dil
leaq 0x190df(%rip), %rsi     # 0x2df2d
callq 0x1225f
leaq 0x2240a(%rip), %rax     # 0x37264
cmpl $0x0, (%rax)
movq 0x5a0a4(%rip), %rcx     # 0x6ef08
je 0x14eb4
cmpl $0x0, 0x8(%rcx)
jne 0x14eb4
movq 0x5a07d(%rip), %rax     # 0x6eef0
testq %rax, %rax
je 0x14e90
movq 0x10(%rax), %rdx
movq %rdx, 0x5a06d(%rip)     # 0x6eef0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
jmp 0x14e9f
pushq $0x18
popq %rdi
callq 0x4da5
movq 0x5a069(%rip), %rcx     # 0x6ef08
movq %rbx, (%rax)
movq 0x5a007(%rip), %rdx     # 0x6eeb0
movq %rdx, 0x10(%rax)
movq %rax, 0x59ffc(%rip)     # 0x6eeb0
andl $0x0, 0x8(%rcx)
popq %rbx
retq