LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: uno_complain
static void
uno_complain(SymRef *r, char *qualify, char *issue)
{
	if (strcmp(qualify, "extern ") == 0)	/* unused extern */
	{	char *p = strstr(r->n->hdr.fnm, ".h");
		if (p && strcmp(p, ".h") == 0)	/* in header file */
			return;			/* too fussy */
	}

	fprintf(stdout, "uno: ");
	if (r->n) fprintf(stdout, "%s:%d:", r->n->hdr.fnm, r->n->hdr.line);
	fprintf(stdout, "\t%sglobal variable '%s' %s\n",
		qualify, r->sm->nme->str, issue);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x71f8(%rip), %rsi      # 0x200d3
movq %r14, %rdi
callq 0x3190
testl %eax, %eax
je 0x18f58
movq 0x1f0e2(%rip), %r12     # 0x37fd0
movq (%r12), %rcx
leaq 0x16d74(%rip), %rdi     # 0x2fc6d
movl $0x5, %esi
movl $0x1, %edx
callq 0x3270
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x18f2a
movq (%r12), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
leaq 0x174c6(%rip), %rsi     # 0x303e9
xorl %eax, %eax
callq 0x31a0
movq (%r12), %rdi
movq (%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x17469(%rip), %rsi     # 0x303a9
movq %r14, %rdx
movq %rbx, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31a0
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x1743f(%rip), %rsi     # 0x303a6
callq 0x3280
testq %rax, %rax
je 0x18ee7
cmpb $0x2e, (%rax)
jne 0x18ee7
cmpb $0x68, 0x1(%rax)
jne 0x18ee7
cmpb $0x0, 0x2(%rax)
jne 0x18ee7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: fct_details
static void
fct_details(FILE *fd, State *s)
{	Trans *t;
	State *ns;
	treenode *exp = (treenode *) 0;

	if (!s || !s->n || s->visited)
		return;

	s->visited = 1;

	if (s->n->hdr.type == TN_IF)
		exp = ((if_node *)s->n)->cond;
	else if (s->n->hdr.type != TN_LABEL)
		exp = s->n;

	for (t = s->succ; t; t = t->nxt)
	{	ns = t->branch;
		if (!ns || !ns->n)
		{	if (exp)
				fprintf(fd, ">0>\n[%s]\n<%lu<\n",
				x_stmnt(exp), s->uno_state);
			continue;
		}
		if (ns->visited)
			fprintf(fd, "{%lu}\n", ns->uno_state);
		else
		{	ns->uno_state = Cnt++;
			fprintf(fd, ">%lu>\n", ns->uno_state);
		}
		fprintf(fd, "[%s", x_stmnt(exp));
		if (t->cond) fprintf(fd, " == %s", x_stmnt(t->cond));
		fprintf(fd, "]\n");
		fct_details(fd, ns);
		fprintf(fd, "<%lu<\n", s->uno_state);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x1910a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x190fc
cmpw $0x0, 0x4a(%rbx)
jne 0x190fc
movq %rdi, %r14
movw $0x1, 0x4a(%rbx)
movl 0x1c(%r15), %eax
cmpl $0x22, %eax
je 0x18fe9
cmpl $0x1b, %eax
jne 0x18fec
movq 0x40(%r15), %r15
jmp 0x18fec
xorl %r15d, %r15d
movq 0x50(%rbx), %r13
testq %r13, %r13
je 0x190fc
leaq 0x1744a(%rip), %r12     # 0x3044a
movq 0x10(%r13), %rbp
testq %rbp, %rbp
je 0x19027
cmpq $0x0, (%rbp)
je 0x19027
cmpw $0x0, 0x4a(%rbp)
je 0x19055
movq 0x40(%rbp), %rdx
movq %r14, %rdi
leaq 0x1742c(%rip), %rsi     # 0x30451
jmp 0x19075
testq %r15, %r15
je 0x190ef
movq %r15, %rdi
callq 0x5cbe
movq 0x40(%rbx), %rcx
movq %r14, %rdi
leaq 0x173fb(%rip), %rsi     # 0x30441
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
jmp 0x190ef
movq 0x1f13c(%rip), %rdx     # 0x38198
leaq 0x1(%rdx), %rax
movq %rax, 0x1f131(%rip)     # 0x38198
movq %rdx, 0x40(%rbp)
movq %r14, %rdi
leaq 0x173e3(%rip), %rsi     # 0x30458
xorl %eax, %eax
callq 0x31a0
movq %r15, %rdi
callq 0x5cbe
movq %r14, %rdi
leaq 0x173d1(%rip), %rsi     # 0x3045f
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
movq (%r13), %rdi
testq %rdi, %rdi
je 0x190ba
callq 0x5cbe
movq %r14, %rdi
leaq 0x173b3(%rip), %rsi     # 0x30463
movq %rax, %rdx
xorl %eax, %eax
callq 0x31a0
movl $0x2, %esi
movl $0x1, %edx
leaq 0x173a0(%rip), %rdi     # 0x3046b
movq %r14, %rcx
callq 0x3270
movq %r14, %rdi
movq %rbp, %rsi
callq 0x18f9e
movq 0x40(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31a0
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x19000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_hunt
static void
nut_hunt(FILE *fd, State *s)
{	Trans *t;
	Nuts *q;

	if (!s || !s->n) return;

	if (s->visited)
	{	fprintf(fd, "{%lu}\n", s->uno_state);
		return;
	}
	s->visited = 1;
	s->uno_state = Cnt++;

	fprintf(fd, ">%lu>\n", s->uno_state);

	if (!s->n->hdr.nuts)
		fprintf(fd, "[]\n");
	for (q = s->n->hdr.nuts; q; q = q->nxt)
		fprintf(fd, "[%s]\n", q->nut);

	for (t = s->direct; t; t = t->nxt)
	{	nut_hunt(fd, t->branch);
		fprintf(fd, "<%lu<\n", s->uno_state);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1920d
movq %rsi, %r14
cmpq $0x0, (%rsi)
je 0x1920d
movq %rdi, %rbx
cmpw $0x0, 0x4a(%r14)
je 0x19154
movq 0x40(%r14), %rdx
leaq 0x17312(%rip), %rsi     # 0x30451
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31a0
movw $0x1, 0x4a(%r14)
movq 0x1f036(%rip), %rdx     # 0x38198
leaq 0x1(%rdx), %rax
movq %rax, 0x1f02b(%rip)     # 0x38198
movq %rdx, 0x40(%r14)
leaq 0x172e0(%rip), %rsi     # 0x30458
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31a0
movq (%r14), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
jne 0x191b3
leaq 0x172d5(%rip), %rdi     # 0x3046a
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3270
movq (%r14), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x191d5
leaq 0x172b4(%rip), %r15     # 0x3046e
movq (%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x191ba
movq 0x58(%r14), %r12
testq %r12, %r12
je 0x1920d
leaq 0x17265(%rip), %r15     # 0x3044a
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x1910b
movq 0x40(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31a0
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x191e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_lts.c
// Function: nut_prepare
static void
nut_prepare(State *from, State *to)	/* insert forward arcs to nodes with a nut attached */
{	Trans *t;

	if (!to || !to->n || to->visited)
		return;
	to->visited = 1;

	if (to->n->hdr.nuts
	|| !(to->succ && to->succ->branch))
	{	for (t = from->direct; t; t = t->nxt)
			if (t->branch == to)
				break;
		if (!t)
		{	t = get_trans();
			t->branch = to;
			t->nxt = from->direct;
			from->direct = t;
		}
		return;
	}

	for (t = to->succ; t; t = t->nxt)
		nut_prepare(from, t->branch);
}

// Assembly:
testq %rsi, %rsi
je 0x192d1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x192cc
cmpw $0x0, 0x4a(%r14)
jne 0x192cc
movq %rdi, %rbx
movw $0x1, 0x4a(%r14)
cmpq $0x0, 0x20(%rax)
je 0x1928b
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x19268
cmpq %r14, 0x10(%rax)
je 0x192cc
movq 0x18(%rax), %rax
jmp 0x19257
movq 0x56c69(%rip), %rax     # 0x6fed8
testq %rax, %rax
je 0x192b2
movq 0x18(%rax), %rcx
movq %rcx, 0x56c59(%rip)     # 0x6fed8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x192bc
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x19253
cmpq $0x0, 0x10(%r15)
je 0x19253
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x19219
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x1929b
jmp 0x192cc
movl $0x20, %edi
callq 0x5fdd
movq %r14, 0x10(%rax)
movq 0x58(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/explore.c
// Function: exclude_location
int
exclude_location(treenode *n)
{
	if (!xrepro || !n || !n->hdr.fnm) return 1;

	if (Verbose) return 0;

	return (strncmp(W_FILE, "./_", 3) == 0
	     || strncmp(W_FILE, "/usr/include", strlen("/usr/include")) == 0
	     || strncmp(W_FILE, "/usr/lib", strlen("/usr/lib")) == 0);
}

// Assembly:
testq %rdi, %rdi
je 0x1a0d5
pushq %rbx
leaq 0x1e1ab(%rip), %rax     # 0x3824c
cmpl $0x0, (%rax)
je 0x1a0ce
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x1a0ce
leaq 0x1e182(%rip), %rcx     # 0x38238
xorl %eax, %eax
cmpl $0x0, (%rcx)
jne 0x1a0d3
cmpb $0x2e, (%rbx)
jne 0x1a0db
cmpb $0x2f, 0x1(%rbx)
jne 0x1a0db
cmpb $0x5f, 0x2(%rbx)
jne 0x1a0db
movl $0x1, %eax
popq %rbx
retq
movl $0x1, %eax
retq
leaq 0x15b68(%rip), %rsi     # 0x2fc4a
movl $0xc, %edx
movq %rbx, %rdi
callq 0x3080
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x1a0d3
leaq 0x16483(%rip), %rsi     # 0x30584
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3080
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x1a0d3
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/explore.c
// Function: has_default
int
has_default(treenode *n)
{
	if (!n
	||  SWITCH(n)
	||  B_TYPE(n) == LEAF_T)
	{	return 0;
	}

        if (B_TYPE(n) == NODE_T
	&&  W_TYPE(n) == TN_LABEL
	&&  B_TYPE(n->lnode) == LEAF_T)
	{	return (n->lnode->hdr.tok == DEFLT);
	}

	return has_default(n->rnode) || has_default(n->lnode);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1a1d1
movq %rdi, %r14
movl 0x1c(%r14), %eax
cmpl $0x21, %eax
je 0x1a1d1
movl (%r14), %ecx
cmpl $0x4, %ecx
je 0x1a198
cmpl $0x1, %ecx
jne 0x1a1a6
jmp 0x1a1d1
cmpl $0x22, %eax
jne 0x1a1a6
movq 0x40(%r14), %rax
cmpl $0x1, (%rax)
je 0x1a1c5
movq 0x48(%r14), %rdi
callq 0x1a172
testl %eax, %eax
jne 0x1a1be
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0x1a180
jmp 0x1a1d1
movl $0x1, %ebx
jmp 0x1a1d1
xorl %ebx, %ebx
cmpl $0x113, 0x18(%rax)      # imm = 0x113
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/explore.c
// Function: has_extern
int
has_extern(treenode *n)
{
	assert(W_TYPE(n) == TN_TYPE_LIST);
	assert(n->lnode != NULL);
	
	return (B_TYPE(n->lnode) == LEAF_T
	     && W_TYPE(n->lnode) == TN_TYPE
	     && n->lnode->hdr.tok == EXTRN);
}

// Assembly:
pushq %rax
cmpl $0x14, 0x1c(%rdi)
jne 0x1a206
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x1a225
xorl %eax, %eax
cmpl $0x1, (%rcx)
jne 0x1a204
cmpl $0x2e, 0x1c(%rcx)
jne 0x1a204
xorl %eax, %eax
cmpl $0x118, 0x18(%rcx)      # imm = 0x118
sete %al
popq %rcx
retq
leaq 0x16380(%rip), %rdi     # 0x3058d
leaq 0x16393(%rip), %rsi     # 0x305a7
leaq 0x16396(%rip), %rcx     # 0x305b1
movl $0x297, %edx            # imm = 0x297
callq 0x3130
leaq 0x163a0(%rip), %rdi     # 0x305cc
leaq 0x16374(%rip), %rsi     # 0x305a7
leaq 0x16377(%rip), %rcx     # 0x305b1
movl $0x298, %edx            # imm = 0x298
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/explore.c
// Function: has_non_obj
int
has_non_obj(treenode *n)
{	/* at least one child node is different from TN_OBJ_DEF */

	assert(W_TYPE(n) == TN_TYPE_LIST);

	if (n->lnode)
	{	if (W_TYPE(n->lnode) != TN_OBJ_DEF)
			return 1;
		if (W_TYPE(n->lnode) == TN_TYPE_LIST)
			return has_non_obj(n->lnode);
	}

	if (n->rnode)
	{	if (W_TYPE(n->rnode) != TN_OBJ_DEF)
			return 1;
		if (W_TYPE(n->rnode) == TN_TYPE_LIST)
			return has_non_obj(n->rnode);
	}

	return 0;
}

// Assembly:
cmpl $0x14, 0x1c(%rdi)
jne 0x1a275
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x1a25e
movl $0x1, %eax
cmpl $0x18, 0x1c(%rcx)
jne 0x1a274
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x1a272
movl $0x1, %eax
cmpl $0x18, 0x1c(%rcx)
jne 0x1a274
xorl %eax, %eax
retq
pushq %rax
leaq 0x16310(%rip), %rdi     # 0x3058d
leaq 0x16323(%rip), %rsi     # 0x305a7
leaq 0x16352(%rip), %rcx     # 0x305dd
movl $0x2a3, %edx            # imm = 0x2A3
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/explore.c
// Function: has_lower_case
static char *
has_lower_case(treenode *n)
{	char *ptr;

	if (!n || n->hdr.warned)
	{	return NULL;
	}

	if (B_TYPE(n) == LEAF_T)
	{	if (W_TYPE(n) == TN_IDENT)
		{	char *p = ((leafnode *)n)->data.sval->str;
			while (*p != '\0')
			{	if (islower((int) *p++))
				{	n->hdr.warned++;
					return ((leafnode *)n)->data.sval->str;
		}	}	}
		return NULL;
	}

	if ((ptr = has_lower_case(n->lnode)) != NULL)
	{	n->hdr.warned++;
		return ptr;
	}
	return has_lower_case(n->rnode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a67b
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x0, 0x30(%r14)
jne 0x1a686
cmpl $0x1, (%r14)
je 0x1a643
movq 0x40(%r14), %rdi
callq 0x1a60b
testq %rax, %rax
jne 0x1a67f
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x1a61d
jmp 0x1a686
cmpl $0x2d, 0x1c(%r14)
jne 0x1a67b
movq 0x40(%r14), %rax
movq 0x8(%rax), %rbx
movq %rbx, %r15
movsbq (%r15), %r12
testq %r12, %r12
je 0x1a67b
callq 0x3290
movq (%rax), %rax
incq %r15
testb $0x2, 0x1(%rax,%r12,2)
je 0x1a655
movl $0x1, 0x30(%r14)
jmp 0x1a686
xorl %ebx, %ebx
jmp 0x1a686
incl 0x30(%r14)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: has_node_comp_ops
int
has_node_comp_ops(treenode *n)
{
	if (!n)
		return 0;

	if (n->hdr.type == (unsigned int) TN_EXPR)
	{	switch (n->hdr.tok) {
		case NOT:
		case EQUAL:
		case LESS:
		case LESS_EQ:
		case GRTR:
		case GRTR_EQ:
		case NOT_EQ:
		case AND:
		case OR:
		case B_NOT_EQ:	return 1;

		default:	return 0;
	}	}

	if (n->hdr.type == TN_EMPTY
	||  n->hdr.which == LEAF_T
	||  n->hdr.type == TN_IDENT)
	{	return 0;
	}

	return (has_node_comp_ops(n->lnode)
	||	has_node_comp_ops(n->rnode));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1a706
movq %rdi, %r14
movl 0x1c(%r14), %eax
testl %eax, %eax
je 0x1a6fd
cmpl $0x28, %eax
je 0x1a6d6
cmpl $0x2d, %eax
je 0x1a706
cmpl $0x1, (%r14)
je 0x1a706
movq 0x40(%r14), %rdi
callq 0x1a698
testl %eax, %eax
jne 0x1a701
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x1a6a6
jmp 0x1a706
movl $0xfffffecf, %eax       # imm = 0xFFFFFECF
addl 0x18(%r14), %eax
cmpl $0x31, %eax
ja 0x1a6f9
movl $0x1, %ebx
movabsq $0x200c1800003c1, %rcx  # imm = 0x200C1800003C1
btq %rax, %rcx
jb 0x1a706
xorl %ebx, %ebx
jmp 0x1a706
movl %eax, %ebx
jmp 0x1a706
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: has_node_type
int
has_node_type(treenode *n, int t)
{
	if (!n)
		return 0;

	if (n->hdr.type == (unsigned int) t)
		return 1;

	if (n->hdr.which == LEAF_T)
		return 0;

	return (has_node_type(n->lnode, t)
	||	has_node_type(n->rnode, t));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1a747
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %ebp
cmpl %ebx, 0x1c(%r14)
je 0x1a749
cmpl $0x1, (%r14)
je 0x1a747
movq 0x40(%r14), %rdi
movl %ebx, %esi
callq 0x1a710
testl %eax, %eax
jne 0x1a749
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x1a723
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: v_matched
int
v_matched(treenode *n)
{	Stack *w;

	for (w = v_reps; w; w = w->nxt)
		if (n == w->n)
			return 1;

	if (suppress(n->hdr.fnm, n->hdr.line))
		return 1;

	return 0;
}

// Assembly:
pushq %rax
movq 0x6604f(%rip), %rax     # 0x809a0
testq %rax, %rax
je 0x1a961
cmpq %rdi, (%rax)
je 0x1a97b
movq 0x10(%rax), %rax
jmp 0x1a951
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
callq 0x13395
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x1a980
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: v_reported
int
v_reported(treenode *n)
{	Stack *w;

	if (v_matched(n))
		return 1;

	w = (Stack *) emalloc(sizeof(Stack));
	w->n = n;
	w->nxt = v_reps;
	v_reps = w;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a949
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x1a9b7
movl $0x18, %edi
callq 0x5fdd
movq %rbx, (%rax)
movq 0x65ff6(%rip), %rcx     # 0x809a0
movq %rcx, 0x10(%rax)
movq %rax, 0x65feb(%rip)     # 0x809a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: bound_stats
void
bound_stats(void)
{
	if (!Verbose) return;

	if (size_zero_resolved)
	printf("%4d\tstatic initializers resolved\n", size_zero_resolved);

	if (size_zero)
	printf("%4d\tarrays declared without size\n", size_zero);

	if (size_seen)
	printf("%4d\tarray indices seen\n", size_seen);

	if (size_notfound)
	printf("%4d\tcould not determine array bound (%d distinct vars)\n",
		size_notfound, size_other);

	if (size_deref)
	printf("%4d\tptr derefs in index (not handled yet)\n", size_deref);

	if (size_outofscope)
	printf("%4d\tnon-checked indices (out of scope)\n", size_outofscope);

	if (size_dunno)
	printf("%4d\tarray indices could not be evaluated\n", size_dunno);

	if (simple_checked > simple_known)
	printf("%4d\tarray indices had no known bound\n", simple_checked-simple_known);

	if (size_ok + size_nok)
	printf("%4d\tarray indices checked (%d violations reported)\n",
			size_ok + size_nok, size_nok);

	if (size_is_simple + simple_checked)
	printf("%4d\tsimple indices - %d of which could be and %d were checked)\n",
		size_is_simple, simple_checked, simple_known);

	if (simple_checked > simple_known)
	printf("	(%d had no known bound)\n", simple_checked-simple_known);
}

// Assembly:
leaq 0x1d727(%rip), %rax     # 0x38238
cmpl $0x0, (%rax)
je 0x1ac4e
pushq %rax
movl 0x65e87(%rip), %esi     # 0x809a8
testl %esi, %esi
je 0x1ab33
leaq 0x15f64(%rip), %rdi     # 0x30a90
xorl %eax, %eax
callq 0x3100
movl 0x65e73(%rip), %esi     # 0x809ac
testl %esi, %esi
je 0x1ab4b
leaq 0x15f6e(%rip), %rdi     # 0x30ab2
xorl %eax, %eax
callq 0x3100
movl 0x65e5f(%rip), %esi     # 0x809b0
testl %esi, %esi
je 0x1ab63
leaq 0x15f78(%rip), %rdi     # 0x30ad4
xorl %eax, %eax
callq 0x3100
movl 0x65e4b(%rip), %esi     # 0x809b4
testl %esi, %esi
je 0x1ab81
movl 0x65e45(%rip), %edx     # 0x809b8
leaq 0x15f72(%rip), %rdi     # 0x30aec
xorl %eax, %eax
callq 0x3100
movl 0x65e35(%rip), %esi     # 0x809bc
testl %esi, %esi
je 0x1ab99
leaq 0x15f92(%rip), %rdi     # 0x30b24
xorl %eax, %eax
callq 0x3100
movl 0x65e21(%rip), %esi     # 0x809c0
testl %esi, %esi
je 0x1abb1
leaq 0x15fa5(%rip), %rdi     # 0x30b4f
xorl %eax, %eax
callq 0x3100
movl 0x65e0d(%rip), %esi     # 0x809c4
testl %esi, %esi
je 0x1abc9
leaq 0x15fb5(%rip), %rdi     # 0x30b77
xorl %eax, %eax
callq 0x3100
movl 0x65df9(%rip), %esi     # 0x809c8
subl 0x65df7(%rip), %esi     # 0x809cc
jle 0x1abe5
leaq 0x15fc3(%rip), %rdi     # 0x30ba1
xorl %eax, %eax
callq 0x3100
movl 0x65de9(%rip), %edx     # 0x809d4
movl 0x65ddf(%rip), %esi     # 0x809d0
addl %edx, %esi
je 0x1ac03
leaq 0x15fcb(%rip), %rdi     # 0x30bc7
xorl %eax, %eax
callq 0x3100
movl 0x65dcf(%rip), %esi     # 0x809d8
movl 0x65db9(%rip), %edx     # 0x809c8
movl %esi, %eax
movl 0x65db5(%rip), %ecx     # 0x809cc
addl %edx, %eax
je 0x1ac35
leaq 0x15fd9(%rip), %rdi     # 0x30bfb
xorl %eax, %eax
callq 0x3100
movl 0x65d99(%rip), %edx     # 0x809c8
movl 0x65d97(%rip), %ecx     # 0x809cc
subl %ecx, %edx
leaq 0x8(%rsp), %rsp
jle 0x1ac4e
leaq 0x15ff6(%rip), %rdi     # 0x30c3b
movl %edx, %esi
xorl %eax, %eax
jmp 0x3100
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: bound_reset
void
bound_reset(void)
{
	bounded = uno_dumpbounds(bounded);
	arsize = uno_freears(arsize);
	arnosize = uno_freears(arnosize);
	v_reps = (Stack *) 0;
}

// Assembly:
pushq %rbx
movq 0x657fa(%rip), %rdi     # 0x809e0
callq 0x1b223
xorl %ebx, %ebx
movq %rbx, 0x657ec(%rip)     # 0x809e0
movq 0x657ed(%rip), %rdi     # 0x809e8
callq 0x1b249
movq %rbx, 0x657e1(%rip)     # 0x809e8
movq 0x657e2(%rip), %rdi     # 0x809f0
callq 0x1b249
movq %rbx, 0x657d6(%rip)     # 0x809f0
movq %rbx, 0x6577f(%rip)     # 0x809a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_dumpbounds
static ArBound *
uno_dumpbounds(ArBound *b)
{
	if (b)
	{	uno_dumpbounds(b->nxt);
		b->nxt = freebounds;
		freebounds = b;
	}
	return (ArBound *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1b248
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1b223
movq 0x657cc(%rip), %rax     # 0x80a08
movq %rax, 0x28(%rbx)
movq %rbx, 0x657c1(%rip)     # 0x80a08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_freears
static ArSize *
uno_freears(ArSize *a)
{
	if (a)
	{	uno_freears(a->nxt);
		a->nxt = freears;
		freears = a;
	}
	return (ArSize *) 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1b26e
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1b249
movq 0x65796(%rip), %rax     # 0x809f8
movq %rax, 0x10(%rbx)
movq %rbx, 0x6578b(%rip)     # 0x809f8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: find_ininode
static int
find_ininode(symentry_t *s, treenode *n)
{
	/* find a TN_ASSIGN with lnode equal to b
	   and rnode TN_INIT_BLK
	 */
	if (!n || n->hdr.which == LEAF_T)
		return 0;

	if (n->hdr.type == TN_ASSIGN
	&&  n->rnode->hdr.type == TN_INIT_BLK
	&&  has_right_decl(s, n->lnode))
		return count_leafs(n->rnode);

	return find_ininode(s, n->lnode) + find_ininode(s, n->rnode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x1ba15
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %eax, %eax
movl %eax, %ebp
cmpl $0x1, (%r14)
je 0x1ba19
cmpl $0x1c, 0x1c(%r14)
jne 0x1b9fa
movq 0x48(%r14), %r12
cmpl $0x17, 0x1c(%r12)
jne 0x1b9fa
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1ba32
testl %eax, %eax
jne 0x1ba26
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1b9b8
movq 0x48(%r14), %r14
addl %ebp, %eax
testq %r14, %r14
jne 0x1b9cf
movl %eax, %ebp
jmp 0x1ba19
xorl %ebp, %ebp
xorl %ebx, %ebx
addl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x1ba7d
movl %eax, %ebx
jmp 0x1ba19
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: has_right_decl
static int
has_right_decl(symentry_t *s, treenode *n)
{
	if (n->hdr.type == TN_ARRAY_DECL
	&&  n->lnode->hdr.type == TN_IDENT
	&&  ((leafnode *)(n->lnode))->syment == s)
		return 1;
	if (n->hdr.type == TN_DECL
	&&  n->lnode->hdr.type == TN_PNTR
	&&  has_right_decl(s, n->rnode))
		return 1;
	return 0;
}

// Assembly:
movl 0x1c(%rsi), %eax
cmpl $0x5, %eax
je 0x1ba55
cmpl $0x6, %eax
jne 0x1ba7a
movq 0x40(%rsi), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x1ba7a
cmpq %rdi, 0x38(%rax)
jne 0x1ba7a
movl $0x1, %eax
retq
movq 0x40(%rsi), %rax
cmpl $0x13, 0x1c(%rax)
jne 0x1ba7a
pushq %rax
movq 0x48(%rsi), %rsi
callq 0x1ba32
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
leaq 0x8(%rsp), %rsp
je 0x1ba7a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: count_leafs
static int
count_leafs(treenode *n)
{
	if (!n) return 0;

	if (n->hdr.which == LEAF_T)
	{	if (n->hdr.type == TN_IDENT)
			could_be_fct(((leafnode*)n)->data.sval->str);
		return 1;
	}

	return count_leafs(n->lnode)+count_leafs(n->rnode);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1baa7
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x1, (%r14)
je 0x1bab4
movq 0x40(%r14), %rdi
callq 0x1ba7d
movq 0x48(%r14), %r14
addl %eax, %ebx
testq %r14, %r14
jne 0x1ba8b
jmp 0x1baa9
xorl %ebx, %ebx
xorl %ebp, %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %ebp
cmpl $0x2d, 0x1c(%r14)
jne 0x1baab
movq 0x40(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x13911
jmp 0x1baab
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: loose_bound
static ArBound *
loose_bound(symentry_t *s, int lb, int ub, int bounds)
{	ArBound *b;

	uno_assert((s != NULL), "saw bound without name");

	b = uno_freshbound();
	b->s = s;
	b->ub = ub;
	b->lb = lb;
	b->bounds = bounds;
	return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
xorl %edi, %edi
testq %r15, %r15
setne %dil
leaq 0x15252(%rip), %rsi     # 0x30d42
callq 0x1341d
movq 0x64f0c(%rip), %rax     # 0x80a08
testq %rax, %rax
je 0x1bb1d
movq 0x28(%rax), %rcx
movq %rcx, 0x64efc(%rip)     # 0x80a08
movq $0x0, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0x1bb27
movl $0x30, %edi
callq 0x5fdd
leaq 0x5431a(%rip), %rcx     # 0x6fe48
movl (%rcx), %ecx
movl %ecx, 0x24(%rax)
movq %r15, (%rax)
movl %r14d, 0x1c(%rax)
movl %ebp, 0x20(%rax)
movw %bx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_dig
static ArBound *
uno_dig(symentry_t *s, treenode *n)
{	ArBound *b = (ArBound *) 0;

	switch (n->hdr.type) {
	case TN_ASSIGN:
		b = bound_from_asgn(s, n);
		break;
	case TN_DECL:
	case TN_DECLS:
		b = uno_dig(s, n->lnode);
		if (!b)
		b = uno_dig(s, n->rnode);
		/* fall thru */
	default:
		break;
	}
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movl 0x1c(%r14), %eax
cmpl $0x5, %eax
je 0x1bb67
cmpl $0x10, %eax
jne 0x1bb7e
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1bb4c
testq %rax, %rax
jne 0x1bb90
movq 0x48(%r14), %r14
jmp 0x1bb59
cmpl $0x1c, %eax
jne 0x1bb93
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1bb9c
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: bound_from_asgn
static ArBound *
bound_from_asgn(symentry_t *s, treenode *nn)
{	ArBound *b = (ArBound *) 0;
	int n;

	if (!nn
	||  !nn->lnode
	||   nn->lnode->hdr.type != TN_IDENT
	||  (nn->lnode->syment != s && s))
		return b;

	if (nn->rnode->hdr.type == TN_IDENT)
	{	/* see if we have a bound on this ident already
		 * if so, copy the bounds over to the lnode var
		 */
		if (s != nn->rnode->syment)
		{	b = add_bound(nn->lnode->syment, 0, 0, DUP|FROMASGN);
			b->sameas = nn->rnode->syment;
			/* b->dup set later in fix_dups */
		}
	} else
	{	nogood = 0;
		n = eval_const_expr(nn->rnode, ZT);
		if (!nogood)
			b = add_bound(nn->lnode->syment, n, n+1, (LB|UB|FROMASGN));
	}

	if (debug && b) printf("UU: set bound from asignment\n");
	return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1bbcb
movq %rsi, %rbx
movq 0x40(%rsi), %rax
testq %rax, %rax
je 0x1bbcb
cmpl $0x2d, 0x1c(%rax)
jne 0x1bbcb
movq 0x38(%rax), %rax
cmpq %rdi, %rax
setne %cl
testq %rdi, %rdi
setne %dl
testb %cl, %dl
je 0x1bbd9
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x48(%rbx), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x1bc0b
cmpq %rdi, 0x38(%rcx)
je 0x1bbcb
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x28, %ecx
callq 0x1bc47
movq %rax, %r14
movq 0x48(%rbx), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%r14)
jmp 0x1bbce
movl $0x0, 0x64d83(%rip)     # 0x80998
xorl %r14d, %r14d
movq %rcx, %rdi
xorl %esi, %esi
callq 0x1a750
cmpl $0x0, 0x64d6f(%rip)     # 0x80998
jne 0x1bbce
movq 0x40(%rbx), %rcx
movq 0x38(%rcx), %rdi
movl %eax, %edx
incl %edx
movl %eax, %esi
movl $0xb, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bc47
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_bounds.c
// Function: add_bound
static ArBound *
add_bound(symentry_t *s, int lb, int ub, int bounds)
{	ArBound *b;

	if (!s) return (ArBound *) 0;	/* probably undeclared var such as 'errno' */

	for (b = bounded; b; b = b->nxt)	/* record best guess at values of vars */
		if (b->s == s && !(b->bounds & UNK))
		{	if (bounds & FROMASGN)	/* new bound is definitive */
			{	if (debug>1)
				printf("	old bound on %s removed\n",
					s->nme->str);
				b->bounds |= UNK;	/* continue, there may be more */
			} else if (b->bounds & FROMASGN)	/* and bounds&FORMEXPR */
			{	if (debug>1)
				printf("	ignore new non-asgn bound on %s\n",
					s->nme->str);	/* new bound was not from asgn */
				return (ArBound *) 0;	/* already have a definitive value */
		}	}

	b = loose_bound(s, lb, ub, bounds);	/* this can add multiple FROMEXPR bounds on a var */

	b->nxt = bounded;
	bounded = b;
	return b;
}

// Assembly:
testq %rdi, %rdi
je 0x1bca6
pushq %rax
movq 0x64d8c(%rip), %r8      # 0x809e0
testq %r8, %r8
je 0x1bc8a
xorl %eax, %eax
cmpq %rdi, (%r8)
jne 0x1bc81
movzwl 0x18(%r8), %r9d
testb $0x4, %r9b
jne 0x1bc81
testb $0x8, %cl
jne 0x1bc78
testb $0x8, %r9b
je 0x1bc81
jmp 0x1bca1
orl $0x4, %r9d
movw %r9w, 0x18(%r8)
movq 0x28(%r8), %r8
testq %r8, %r8
jne 0x1bc5b
callq 0x1bacf
movq 0x64d4a(%rip), %rcx     # 0x809e0
movq %rcx, 0x28(%rax)
movq %rax, 0x64d3f(%rip)     # 0x809e0
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_intervals.c
// Function: negate_bound
void
negate_bound(ArBound *b)
{
	if (debug>1) explain_bound("negating", b, ZT);

	uno_assert(!(b->bounds & (DUP|UNK)), "dup or unk in negate");

	if ((b->bounds & LB)
	&&  (b->bounds & UB))
	{	if (b->bounds & NEG)
			b->bounds &= ~NEG;
		else
			b->bounds |= NEG;
	} else if (b->bounds & LB)
	{	b->bounds &= ~LB;
		b->bounds |= UB;
		b->ub = b->lb;
	} else if (b->bounds & UB)
	{	b->bounds &= ~UB;
		b->bounds |= LB;
		b->lb = b->ub;
	} else
	{	printf("uno: zero bounds, cannot happen\n");
		exit(1);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0x18(%rdi), %eax
xorl %edi, %edi
testb $0x24, %al
sete %dil
leaq 0x15115(%rip), %rsi     # 0x30dd8
callq 0x1341d
movzwl 0x18(%rbx), %eax
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x1bcde
testb $0x40, %al
jne 0x1bcf8
orl $0x40, %eax
jmp 0x1bcfb
testb $0x2, %al
jne 0x1bd01
testb $0x1, %al
je 0x1bd12
andl $-0x4, %eax
orl $0x2, %eax
movw %ax, 0x18(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x20(%rbx)
jmp 0x1bd10
andl $-0x41, %eax
movw %ax, 0x18(%rbx)
jmp 0x1bd10
andl $-0x4, %eax
incl %eax
movw %ax, 0x18(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
leaq 0x151bc(%rip), %rdi     # 0x30ed5
callq 0x30a0
movl $0x1, %edi
callq 0x3260
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_intervals.c
// Function: first_inside_second
int
first_inside_second(ArBound *a, ArBound *b)	/* is interval a inside interval b? */
{
	sanitize(a);
	sanitize(b);

	if (unsatisfiable(a)
	||  unsatisfiable(b))
		return 0;

	if (!(a->bounds&NEG) && !(b->bounds&NEG))	/* ...[-2..-1]...[1>... */
		return ((a->lb >= b->lb) && (a->ub <= b->ub));

	if ((a->bounds&NEG) && (b->bounds&NEG))
		return ((a->lb <= b->lb) && (a->ub >= b->ub));

	if (!(a->bounds&NEG) && (b->bounds&NEG))
		return (a->ub <= b->lb || a->lb >= b->ub);

	if ((a->bounds&NEG) && !(b->bounds&NEG))
		return (b->lb >= a->ub || b->ub <= a->lb);

	/* unreachable */
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1bdf2
movq %rbx, %rdi
callq 0x1bdf2
movzwl 0x18(%r14), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpw $0x3, %cx
jne 0x1bd74
movl 0x1c(%r14), %ecx
cmpl 0x20(%r14), %ecx
jle 0x1bdd9
movzwl 0x18(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpw $0x3, %dx
jne 0x1bd8b
movl 0x1c(%rbx), %edx
cmpl 0x20(%rbx), %edx
jle 0x1bdd9
testb $0x40, %al
jne 0x1bda6
movl 0x20(%rbx), %edx
testb $0x40, %cl
jne 0x1bdc2
cmpl %edx, 0x20(%r14)
jl 0x1bdd9
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
jmp 0x1bdbd
testb $0x40, %cl
jne 0x1bdd0
movl 0x20(%rbx), %ecx
movb $0x1, %al
cmpl 0x1c(%r14), %ecx
jge 0x1bddb
movl 0x1c(%rbx), %eax
cmpl 0x20(%r14), %eax
setle %al
jmp 0x1bddb
movb $0x1, %al
cmpl %edx, 0x1c(%r14)
jle 0x1bddb
movl 0x20(%r14), %eax
jmp 0x1bdea
movl 0x20(%r14), %eax
cmpl 0x20(%rbx), %eax
jle 0x1bde6
xorl %eax, %eax
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
setge %al
jmp 0x1bddb
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_intervals.c
// Function: sanitize
void
sanitize(ArBound *a)
{
	if ((a->bounds&UNK)
	||  (a->bounds&DUP))
		return;

	if (!(a->bounds&LB) && !(a->bounds & UB))
		explain_bound("error", a, ZT);

	uno_assert((a->bounds&LB) || (a->bounds & UB), "zerobound error");

	if (!(a->bounds&UB)) a->ub =  INT_MAX;
	if (!(a->bounds&LB)) a->lb = -INT_MAX;

	if (!(a->bounds & NEG)
	||   ((a->bounds & LB) && (a->bounds & UB)))	/* bug found by codesurfer: ; */
		return;

	if (a->bounds & LB)
	{	a->bounds &= ~NEG;
		a->bounds &= ~LB;
		a->bounds |= UB;
		a->ub = a->lb;
	} else if (a->bounds & UB)
	{	a->bounds &= ~NEG;
		a->bounds &= ~UB;
		a->bounds |= LB;
		a->lb = a->ub;
	}
}

// Assembly:
movzwl 0x18(%rdi), %eax
movzwl %ax, %ecx
testb $0x24, %cl
je 0x1bdff
retq
pushq %rbx
movq %rdi, %rbx
testb $0x3, %cl
jne 0x1be1d
leaq 0x1508e(%rip), %rdi     # 0x30e9d
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1a9b9
movzwl 0x18(%rbx), %eax
xorl %edi, %edi
testb $0x3, %al
setne %dil
leaq 0x15067(%rip), %rsi     # 0x30e93
callq 0x1341d
movzwl 0x18(%rbx), %eax
testb $0x1, %al
jne 0x1be40
movl $0x7fffffff, 0x1c(%rbx) # imm = 0x7FFFFFFF
testb $0x2, %al
jne 0x1be4b
movl $0x80000001, 0x20(%rbx) # imm = 0x80000001
testb $0x40, %al
je 0x1be81
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
je 0x1be81
testb $0x2, %al
jne 0x1be72
testb $0x1, %al
je 0x1be81
andl $-0x44, %eax
orl $0x2, %eax
movw %ax, 0x18(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x20(%rbx)
jmp 0x1be81
andl $-0x44, %eax
incl %eax
movw %ax, 0x18(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_intervals.c
// Function: check_bounds
int
check_bounds(ArBound *b, int x, treenode *nn)	/* is bound within interval 0..x-1 ? */
{	char buf[512];
	int result = 1;

	if (b->bounds & DUP)
	{	if (!b->dup)
		{	if (debug>1) printf("dup not set\n");
			return 1;
		}
		b = b->dup;	/* one step only */
	}

	if (unsatisfiable(b))
	{	if (debug) explain_bound("unsatisfiable", b, nn);
		return 1;	/* no run can get here, so this is no error */
	}
	if (!(b->bounds&NEG))
	{	if ((b->bounds&LB) && b->lb < 0)
		{	result = 0;
			sprintf(buf, "array index can be negative (%d)", b->lb);
		}
		if ((b->bounds&UB) && b->ub > x)
		{	result = 0;
			sprintf(buf, "array index can exceed upper-bound (%d>%d), var",
				b->ub-1, x-1);
		}
	} else
	{	result = 0;
		uno_assert((b->bounds & UB) && (b->bounds & LB), "negated non-interval");
		if (b->lb == b->ub - 1)
		{	sprintf(buf, "array index can be unequal to %d", b->lb);
			if (debug)
				printf("	dubious: <%s>\n", buf);
			result = 1;	/* dubious report */
		} else
			sprintf(buf, "array index can be <%d or >=%d", b->lb, b->ub);
	}

	if (result == 0)
	{	size_nok++;
		if (nn)
			uno_warn(buf, nn, b->s);
		else if (debug)
			printf("<<%s>>\n", buf);
	}  else
	{	size_ok++;
		if (debug>1) printf(" satisfied..\n");
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movzwl 0x18(%rdi), %eax
testb $0x20, %al
je 0x1beb2
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1bf4e
movzwl 0x18(%r14), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpw $0x3, %cx
jne 0x1bed1
movl 0x1c(%r14), %ecx
movl $0x1, %r15d
cmpl 0x20(%r14), %ecx
jle 0x1bf86
movzwl %ax, %ecx
testb $0x40, %cl
jne 0x1bf0a
testb $0x2, %cl
je 0x1beea
movl 0x20(%r14), %edx
testl %edx, %edx
js 0x1bf97
xorl %ecx, %ecx
testb $0x1, %al
je 0x1bf41
movl 0x1c(%r14), %edx
cmpl %ebp, %edx
jle 0x1bf41
decl %edx
decl %ebp
leaq 0x14f0b(%rip), %rsi     # 0x30e0e
movq %rsp, %rdi
movl %ebp, %ecx
jmp 0x1bf60
movl %ecx, %edi
shrl %edi
andl %ecx, %edi
andl $0x1, %edi
leaq 0x14f24(%rip), %rsi     # 0x30e3e
callq 0x1341d
movl 0x1c(%r14), %ecx
movl 0x20(%r14), %edx
leal -0x1(%rcx), %eax
cmpl %eax, %edx
jne 0x1bf56
leaq 0x14f1e(%rip), %rsi     # 0x30e53
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3250
jmp 0x1bf45
testb %cl, %cl
jne 0x1bf67
leaq 0x64a84(%rip), %rax     # 0x809d0
incl (%rax)
movl $0x1, %r15d
jmp 0x1bf86
leaq 0x14f17(%rip), %rsi     # 0x30e74
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3250
leaq 0x64a66(%rip), %rax     # 0x809d4
incl (%rax)
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x1bf86
movq (%r14), %rdx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x13457
movl %r15d, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14e4f(%rip), %rsi     # 0x30ded
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3250
movzwl 0x18(%r14), %eax
movb $0x1, %cl
jmp 0x1beec
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_intervals.c
// Function: same_bounds
int
same_bounds(ArBound *a, ArBound *b)	/* true if bound a includes bound b */
{
	if (strcmp(a->s->nme->str, b->s->nme->str) != 0
	||  (a->bounds & UNK) != (b->bounds & UNK))
		return 0;

	if (a->bounds & UNK)
		return 1;

	return first_inside_second(b, a);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1c011
movzwl 0x18(%rbx), %ecx
andl $0x4, %ecx
movzwl 0x18(%r14), %edx
andl $0x4, %edx
cmpw %dx, %cx
jne 0x1c011
movl $0x1, %eax
testw %cx, %cx
jne 0x1c011
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bd43
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: gen_stats
void
gen_stats(void)
{	int i;
	int cnt;

	for (i = cnt = 0; i < 5; i++)
		if (hit_cmds[i])
			cnt++;
	if (cnt)
	{	printf("uno: commands in property executed\n");
		for (i = 0; i < 5; i++)
			if (hit_cmds[i])
			printf("\t%d\t%s\n", hit_cmds[i], cmds[i].cmd);
	}
	for (i = cnt = 0; i < 5; i++)
		if (hit_cmds[i])
			cnt++;
	if (cnt)
	{	printf("uno: fcts in property executed\n");
		for (i = 0; i < 3; i++)
			if (hit_fcts[i])
			printf("\t%d\t%s\n", hit_fcts[i], evals[i].cmd);
	}

	prop_reached(uno_prop);

	if (ruledout)
	printf("uno: %3d errorpaths generated, but ruled out as infeasible\n",
		ruledout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
leaq 0x64773(%rip), %r14     # 0x80a20
xorl %ecx, %ecx
cmpl $0x1, (%rax,%r14)
sbbl $-0x1, %ecx
addq $0x4, %rax
cmpq $0x14, %rax
jne 0x1c2af
testl %ecx, %ecx
je 0x1c305
leaq 0x1513a(%rip), %rdi     # 0x31406
callq 0x30a0
leaq 0x1ba48(%rip), %r15     # 0x37d20
leaq 0x14c41(%rip), %rbx     # 0x30f20
xorl %r12d, %r12d
movl (%r12,%r14), %esi
testl %esi, %esi
je 0x1c2f7
movq (%r15), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3100
addq $0x10, %r15
addq $0x4, %r12
cmpq $0x14, %r12
jne 0x1c2e2
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x1, (%rax,%r14)
sbbl $-0x1, %ecx
addq $0x4, %rax
cmpq $0x14, %rax
jne 0x1c309
testl %ecx, %ecx
je 0x1c366
leaq 0x15103(%rip), %rdi     # 0x31429
callq 0x30a0
leaq 0x1ba5e(%rip), %r14     # 0x37d90
leaq 0x64707(%rip), %r15     # 0x80a40
leaq 0x14be0(%rip), %rbx     # 0x30f20
xorl %r12d, %r12d
movl (%r12,%r15), %esi
testl %esi, %esi
je 0x1c358
movq (%r14), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3100
addq $0x10, %r14
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x1c343
leaq 0x53b3b(%rip), %rax     # 0x6fea8
movq (%rax), %rdi
callq 0x1c3a4
movl 0x646e5(%rip), %esi     # 0x80a60
testl %esi, %esi
je 0x1c398
leaq 0x14ba2(%rip), %rdi     # 0x30f28
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: prop_reached
static void
prop_reached(State *s)
{	Trans *t;

	if (!s || !s->n) return;

	if (!s->visited
	&&  !strstr(s->n->hdr.fnm, " after "))
		printf("uno: %s:%d: not reached\n",
			s->n->hdr.fnm, s->n->hdr.line);

	s->visited = 1;	/* prevent duplicate reports */

	for (t = s->succ; t && t->branch; t = t->nxt)
		prop_reached(t->branch);
}

// Assembly:
testq %rdi, %rdi
je 0x1c415
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1c410
cmpw $0x0, 0x4a(%rbx)
jne 0x1c3ed
movq 0x8(%r15), %r14
leaq 0x14cc9(%rip), %rsi     # 0x31094
movq %r14, %rdi
callq 0x3280
testq %rax, %rax
jne 0x1c3ed
movl 0x10(%r15), %edx
leaq 0x14cb9(%rip), %rdi     # 0x3109c
movq %r14, %rsi
xorl %eax, %eax
callq 0x3100
movw $0x1, 0x4a(%rbx)
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x1c410
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1c410
callq 0x1c3a4
movq 0x18(%rbx), %rbx
jmp 0x1c3f7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: has_ident
static int
has_ident(treenode *n, char *s)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT)
		return (strcmp(((leafnode *)n)->data.sval->str, s) == 0);

	if (n->hdr.which != LEAF_T)
		switch (n->hdr.type) {
		case TN_SWITCH:
		case TN_WHILE:
		case TN_DOWHILE:
			return has_ident(n->lnode, s);
		default:
			return has_ident(n->lnode, s) || has_ident(n->rnode, s);
		}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1c7cd
movq %rsi, %r14
movq %rdi, %r15
movl 0x1c(%r15), %eax
cmpl $0x2d, %eax
je 0x1c7af
cmpl $0x1, (%r15)
je 0x1c7cd
addl $-0x1f, %eax
leaq 0x40(%r15), %rcx
cmpl $0x2, %eax
jbe 0x1c7a5
movq (%rcx), %rdi
movq %r14, %rsi
callq 0x1c762
testl %eax, %eax
jne 0x1c7c8
addq $0x48, %r15
movq %r15, %rcx
movq (%rcx), %r15
testq %r15, %r15
jne 0x1c774
jmp 0x1c7cd
movq 0x40(%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3190
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
jmp 0x1c7cd
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: match_args
static int
match_args(treenode *e, treenode *n, int which)	/* 1:match(mark,with,without) 2:marked(x,with,without) */
{	treenode *f, *g;
	int val1, val2, mark;

	/*	   TN_FUNC_CALL:e
		      /    \
		     /      \
		TN_IDENT  TN_EXPR_LIST:f
		   /          /         \
		match        /       TN_INT:val2
	           TN_EXPR_LIST:g
	                  /      \
		  TN_INT:mark    TN_INT:val1
	 */
		if (!e->rnode
		||   e->rnode->hdr.type != TN_EXPR_LIST)
			goto bad1;
	f = e->rnode;
		if (!f->lnode
		||   f->lnode->hdr.type != TN_EXPR_LIST)
			goto bad1;
	g = f->lnode;
		if (!g->lnode || !g->rnode)
			goto bad1;
	nogood = 0;
	val1 = eval_const_expr(g->rnode, n);
	val2 = eval_const_expr(f->rnode, n);
	mark = eval_const_expr(g->lnode, n);
	if (nogood)
	{
bad1:		err_path++;
		fprintf(stderr, "\t\t%s:%d: error match_args in '%s'\n",
			n?n->hdr.fnm:"--", n?n->hdr.line:0, x_stmnt(e));
		exit(1);
	}

	if (debug)
	{	err_path++;
		printf("%3d>>saw %s(%s,%d,%d)\n", depth, x_stmnt(e), user_name, val1, val2);
		err_path--;
	}
	return domatch(n, mark, val1, val2, which);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x1cb03
cmpl $0xa, 0x1c(%r15)
jne 0x1cb03
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x1cb03
cmpl $0xa, 0x1c(%r12)
jne 0x1cb03
cmpq $0x0, 0x40(%r12)
je 0x1cb03
movq 0x48(%r12), %rdi
testq %rdi, %rdi
je 0x1cb03
leaq 0x63f96(%rip), %rbp     # 0x80998
movl $0x0, (%rbp)
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x1a750
movl %eax, %r14d
movq 0x48(%r15), %rdi
movq %rbx, %rsi
callq 0x1a750
movl %eax, 0x14(%rsp)
movq 0x40(%r12), %rdi
movq %rbx, %rsi
callq 0x1a750
cmpl $0x0, (%rbp)
jne 0x1cb03
xorl %ebx, %ebx
cmpq $0x0, 0x8(%rsp)
je 0x1caf2
movl %eax, %r12d
cmpl $0x2, 0x10(%rsp)
je 0x1ca68
movq 0x8(%rsp), %rcx
cmpq $0x0, 0x28(%rcx)
je 0x1caf2
movq 0x63ff9(%rip), %rcx     # 0x80a68
movq (%rcx), %rbp
testq %rbp, %rbp
je 0x1caf2
xorl %ebx, %ebx
cmpl %r12d, 0x14(%rbp)
jne 0x1caa8
movl 0x10(%rbp), %r13d
testl %r14d, %r13d
je 0x1caa8
movl %r13d, %ecx
andl 0x14(%rsp), %ecx
jne 0x1caa8
cmpl $0x2, 0x10(%rsp)
jne 0x1cab3
orl $0x1000000, %r13d       # imm = 0x1000000
movl %r13d, 0x10(%rbp)
movl $0x1, %ebx
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0x1ca79
jmp 0x1caf2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x1caa8
cmpl $0x0, (%r15)
je 0x1caec
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
je 0x1ca98
movq 0x10(%r15), %r15
jmp 0x1cac0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4306
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_add
static void
sym_add(treenode *m, int allow, int forbid)
{	SymRef *s;
	SymList *r;
	treenode *n;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;
	if (!n || !n->hdr.defuse)
	{	if (debug) printf("	symadd - nothing to add\n");
		return;
	}

	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if (debug) printf("\tsymadd sees %s mark %d, looking for %d & !%d\n",
			r->sm->nme->str, r->mark, allow, forbid);

		if ((r->mark & allow) && !(r->mark & forbid))
		{	for (s = gen_stack->symrefs; s; s = s->nxt)
				if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0
				&&  (unsigned int) s->status == r->mark)
				{	if (debug) printf("\tsymadd %s - already there\n",
						s->sm->nme->str);
					break;
				}
			if (!s)
			{	s = uno_getref(r->sm);
				s->nxt = gen_stack->symrefs;
				s->status = r->mark;
				s->n = n;
				gen_stack->symrefs = s;
				if (debug) printf("\tadded %s (line %d)\n",
					s->sm->nme->str, s->n?s->n->hdr.line:-1);
		}	}
	}
	if (debug) printf("\tsymadd - done\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x1d701
movl %esi, %ebp
movq 0x8(%rsp), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x1d659
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1d701
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1d701
movq 0x18(%rax), %r13
testq %r13, %r13
je 0x1d701
movl 0x4(%r13), %r14d
testl %ebp, %r14d
sete %al
testl %r14d, 0x14(%rsp)
setne %cl
orb %al, %cl
jne 0x1d6f8
movq 0x633d3(%rip), %rax     # 0x80a68
movq (%rax), %rbx
movq 0x8(%r13), %r15
testq %rbx, %rbx
je 0x1d6cf
movq 0x8(%r15), %rax
movq 0x8(%rax), %r12
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3190
testl %eax, %eax
jne 0x1d6c6
cmpl %r14d, 0x10(%rbx)
je 0x1d6f8
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d6a9
movq %r15, %rdi
callq 0x13853
movq 0x6338a(%rip), %rcx     # 0x80a68
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movl 0x4(%r13), %edx
movl %edx, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%r13), %r13
jmp 0x1d66f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_del
static void
sym_del(treenode *m, int allow, int forbid)
{	SymRef *s, *os;
	SymList *r;
	treenode *n;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if ((r->mark & allow) && !(r->mark & forbid))
		{	os = (SymRef *) 0;
again:			for (s = gen_stack->symrefs; s; os = s, s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0
				&&  (s->status & allow)
				&& !(s->status & forbid))
				{	if (!os)
						gen_stack->symrefs = s->nxt;
					else
						os->nxt = s->nxt;

					if (debug) printf("\tdeleted %s\n",
						s->sm->nme->str);

					goto again;
	}	}	}	}
}

// Assembly:
testq %rdi, %rdi
je 0x1d805
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x1b, 0x1c(%rdi)
jne 0x1d73b
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x1d7f7
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1d7f7
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x1d7f7
movq 0x6330c(%rip), %rax     # 0x80a68
movq %rax, (%rsp)
movl 0x4(%r15), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
jne 0x1d7ea
movq (%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1d7ea
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %r14
xorl %r12d, %r12d
movq %rax, %r13
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3190
testl %eax, %eax
jne 0x1d7b9
movl 0x10(%r13), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
je 0x1d7c7
movq 0x18(%r13), %rax
movq %r13, %r12
testq %rax, %rax
jne 0x1d78d
jmp 0x1d7ea
movq 0x18(%r13), %rax
testq %r12, %r12
je 0x1d7db
movq %rax, 0x18(%r12)
movq (%rsp), %rax
jmp 0x1d7e5
movq (%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, %rax
movq (%rax), %rax
jmp 0x1d7c0
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1d760
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq