LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %r14, %r14
je 0x18514
cmpl %ebx, 0x1c(%r14)
je 0x18512
cmpl $0x1, (%r14)
je 0x18514
movq 0x40(%r14), %rdi
movl %ebx, %esi
callq 0x184de
testl %eax, %eax
jne 0x18512
movq 0x48(%r14), %r14
jmp 0x184ea
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x6727b(%rip), %rcx     # 0x7f9a0
pushq $0x1
popq %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x1873b
leaq 0x10(%rdx), %rcx
cmpq %rdi, (%rdx)
jne 0x18728
jmp 0x18753
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
callq 0x121e1
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1871d
testl %eax, %eax
je 0x18767
pushq $0x1
popq %rax
jmp 0x18786
pushq $0x18
popq %rdi
callq 0x4da5
movq %rbx, (%rax)
movq 0x67227(%rip), %rcx     # 0x7f9a0
movq %rcx, 0x10(%rax)
movq %rax, 0x6721c(%rip)     # 0x7f9a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e95a(%rip), %rax     # 0x37238
cmpl $0x0, (%rax)
je 0x18a1b
pushq %rax
movl 0x670ba(%rip), %esi     # 0x7f9a8
testl %esi, %esi
je 0x18900
leaq 0x161cb(%rip), %rdi     # 0x2eac4
xorl %eax, %eax
callq 0x3100
movl 0x670a6(%rip), %esi     # 0x7f9ac
testl %esi, %esi
je 0x18918
leaq 0x161d5(%rip), %rdi     # 0x2eae6
xorl %eax, %eax
callq 0x3100
movl 0x67092(%rip), %esi     # 0x7f9b0
testl %esi, %esi
je 0x18930
leaq 0x161df(%rip), %rdi     # 0x2eb08
xorl %eax, %eax
callq 0x3100
movl 0x6707e(%rip), %esi     # 0x7f9b4
testl %esi, %esi
je 0x1894e
movl 0x67078(%rip), %edx     # 0x7f9b8
leaq 0x161d9(%rip), %rdi     # 0x2eb20
xorl %eax, %eax
callq 0x3100
movl 0x67068(%rip), %esi     # 0x7f9bc
testl %esi, %esi
je 0x18966
leaq 0x161f9(%rip), %rdi     # 0x2eb58
xorl %eax, %eax
callq 0x3100
movl 0x67054(%rip), %esi     # 0x7f9c0
testl %esi, %esi
je 0x1897e
leaq 0x1620c(%rip), %rdi     # 0x2eb83
xorl %eax, %eax
callq 0x3100
movl 0x67040(%rip), %esi     # 0x7f9c4
testl %esi, %esi
je 0x18996
leaq 0x1621c(%rip), %rdi     # 0x2ebab
xorl %eax, %eax
callq 0x3100
movl 0x6702c(%rip), %esi     # 0x7f9c8
subl 0x6702a(%rip), %esi     # 0x7f9cc
jle 0x189b2
leaq 0x1622a(%rip), %rdi     # 0x2ebd5
xorl %eax, %eax
callq 0x3100
movl 0x6701c(%rip), %edx     # 0x7f9d4
movl 0x67012(%rip), %esi     # 0x7f9d0
addl %edx, %esi
je 0x189d0
leaq 0x16232(%rip), %rdi     # 0x2ebfb
xorl %eax, %eax
callq 0x3100
movl 0x67002(%rip), %esi     # 0x7f9d8
movl 0x66fec(%rip), %edx     # 0x7f9c8
movl %esi, %eax
movl 0x66fe8(%rip), %ecx     # 0x7f9cc
addl %edx, %eax
je 0x18a02
leaq 0x16240(%rip), %rdi     # 0x2ec2f
xorl %eax, %eax
callq 0x3100
movl 0x66fcc(%rip), %edx     # 0x7f9c8
movl 0x66fca(%rip), %ecx     # 0x7f9cc
subl %ecx, %edx
leaq 0x8(%rsp), %rsp
jle 0x18a1b
leaq 0x1625d(%rip), %rdi     # 0x2ec6f
movl %edx, %esi
xorl %eax, %eax
jmp 0x3100
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x66a82(%rip), %rdi     # 0x7f9e0
callq 0x18f9d
andq $0x0, 0x66a75(%rip)     # 0x7f9e0
movq 0x66a76(%rip), %rdi     # 0x7f9e8
callq 0x18fc3
andq $0x0, 0x66a69(%rip)     # 0x7f9e8
movq 0x66a6a(%rip), %rdi     # 0x7f9f0
callq 0x18fc3
andq $0x0, 0x66a5d(%rip)     # 0x7f9f0
andq $0x0, 0x66a05(%rip)     # 0x7f9a0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18fc2
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x18f9d
movq 0x66a52(%rip), %rax     # 0x7fa08
movq %rax, 0x28(%rbx)
movq %rbx, 0x66a47(%rip)     # 0x7fa08
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18fe8
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x18fc3
movq 0x66a1c(%rip), %rax     # 0x7f9f8
movq %rax, 0x10(%rbx)
movq %rbx, 0x66a11(%rip)     # 0x7f9f8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %ebp, %ebp
testq %r14, %r14
je 0x19754
cmpl $0x1, (%r14)
je 0x19754
cmpl $0x1c, 0x1c(%r14)
jne 0x19736
movq 0x48(%r14), %r12
cmpl $0x17, 0x1c(%r12)
jne 0x19736
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1978c
testl %eax, %eax
jne 0x1974a
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x196f6
movq 0x48(%r14), %r14
addl %eax, %ebp
jmp 0x19708
movq %r12, %rdi
callq 0x197cf
movl %eax, %ebx
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_bounds.c
// Function: getars
static ArSize *
getars(void)
{	ArSize *a;

	if (freears)
	{	a = freears;
		freears = freears->nxt;
		memset(a, 0, sizeof(ArSize));
	} else
		a = (ArSize *) emalloc(sizeof(ArSize));

	return a;
}

// Assembly:
movq 0x66290(%rip), %rax     # 0x7f9f8
testq %rax, %rax
je 0x19784
movq 0x10(%rax), %rcx
movq %rcx, 0x66280(%rip)     # 0x7f9f8
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
retq
pushq $0x18
popq %rdi
jmp 0x4da5
// File: /workspace/github_c_makefile_star2_O2/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 0x197ab
cmpl $0x6, %eax
jne 0x197cc
movq 0x40(%rsi), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x197cc
cmpq %rdi, 0x38(%rax)
jne 0x197cc
jmp 0x197c8
movq 0x40(%rsi), %rax
cmpl $0x13, 0x1c(%rax)
jne 0x197cc
pushq %rax
movq 0x48(%rsi), %rsi
callq 0x1978c
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x197cc
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
testq %r14, %r14
je 0x1980d
cmpl $0x1, (%r14)
je 0x197f6
movq 0x40(%r14), %rdi
callq 0x197cf
movq 0x48(%r14), %r14
addl %eax, %ebp
jmp 0x197da
pushq $0x1
popq %rbx
cmpl $0x2d, 0x1c(%r14)
jne 0x1980d
movq 0x40(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x126f9
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1553f(%rip), %rsi     # 0x2ed76
callq 0x1225f
movq 0x661c5(%rip), %rax     # 0x7fa08
testq %rax, %rax
je 0x19861
movq 0x28(%rax), %rcx
movq %rcx, 0x661b5(%rip)     # 0x7fa08
andq $0x0, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0x19869
pushq $0x30
popq %rdi
callq 0x4da5
leaq 0x555d8(%rip), %rcx     # 0x6ee48
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_O2/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 0x198a9
cmpl $0x10, %eax
jne 0x198c0
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1988e
testq %rax, %rax
jne 0x198d2
movq 0x48(%r14), %r14
jmp 0x1989b
cmpl $0x1c, %eax
jne 0x198d5
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x198de
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1990d
movq %rsi, %rbx
movq 0x40(%rsi), %rax
testq %rax, %rax
je 0x1990d
cmpl $0x2d, 0x1c(%rax)
jne 0x1990d
movq 0x38(%rax), %rax
cmpq %rdi, %rax
setne %cl
testq %rdi, %rdi
setne %dl
testb %cl, %dl
je 0x1991b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x48(%rbx), %rcx
cmpl $0x2d, 0x1c(%rcx)
jne 0x1994b
cmpq %rdi, 0x38(%rcx)
je 0x1990d
pushq $0x28
popq %rcx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19982
movq %rax, %r14
movq 0x48(%rbx), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%r14)
jmp 0x19910
andl $0x0, 0x66046(%rip)     # 0x7f998
xorl %r14d, %r14d
movq %rcx, %rdi
xorl %esi, %esi
callq 0x18519
cmpl $0x0, 0x66032(%rip)     # 0x7f998
jne 0x19910
movq 0x40(%rbx), %rcx
movq 0x38(%rcx), %rdi
movl %eax, %edx
incl %edx
pushq $0xb
popq %rcx
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19982
// File: /workspace/github_c_makefile_star2_O2/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 0x199e1
pushq %rax
leaq 0x66051(%rip), %r8      # 0x7f9e0
xorl %eax, %eax
movq (%r8), %r8
testq %r8, %r8
je 0x199c5
cmpq %rdi, (%r8)
jne 0x199bf
movzwl 0x18(%r8), %r9d
testb $0x4, %r9b
jne 0x199bf
testb $0x8, %cl
jne 0x199b6
testb $0x8, %r9b
je 0x199bf
jmp 0x199dc
orl $0x4, %r9d
movw %r9w, 0x18(%r8)
addq $0x28, %r8
jmp 0x19991
callq 0x19816
movq 0x6600f(%rip), %rcx     # 0x7f9e0
movq %rcx, 0x28(%rax)
movq %rax, 0x66004(%rip)     # 0x7f9e0
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15411(%rip), %rsi     # 0x2ee0c
callq 0x1225f
movzwl 0x18(%rbx), %eax
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x19a16
testb $0x40, %al
jne 0x19a30
orl $0x40, %eax
jmp 0x19a33
testb $0x2, %al
jne 0x19a39
testb $0x1, %al
je 0x19a4a
andl $-0x4, %eax
orl $0x2, %eax
movw %ax, 0x18(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x20(%rbx)
jmp 0x19a48
andl $-0x41, %eax
movw %ax, 0x18(%rbx)
jmp 0x19a48
andl $-0x4, %eax
incl %eax
movw %ax, 0x18(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
leaq 0x154b8(%rip), %rdi     # 0x2ef09
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x3270
// File: /workspace/github_c_makefile_star2_O2/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 0x19b14
movq %rbx, %rdi
callq 0x19b14
movq %r14, %rdi
callq 0x19a5e
testl %eax, %eax
jne 0x19aa8
movq %rbx, %rdi
callq 0x19a5e
testl %eax, %eax
je 0x19ab5
xorl %eax, %eax
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x40, 0x18(%r14)
movzwl 0x18(%rbx), %eax
jne 0x19ad6
movl 0x20(%rbx), %ecx
testb $0x40, %al
jne 0x19af1
cmpl %ecx, 0x20(%r14)
jl 0x19aa8
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
jmp 0x19aec
testb $0x40, %al
jne 0x19aff
movl 0x20(%rbx), %ecx
movb $0x1, %al
cmpl 0x1c(%r14), %ecx
jge 0x19aaa
movl 0x1c(%rbx), %eax
cmpl 0x20(%r14), %eax
setle %al
jmp 0x19aaa
movb $0x1, %al
cmpl %ecx, 0x1c(%r14)
jle 0x19aaa
movl 0x20(%r14), %eax
jmp 0x19b0c
movl 0x20(%r14), %eax
cmpl 0x20(%rbx), %eax
jg 0x19aa8
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
setge %al
jmp 0x19aaa
// File: /workspace/github_c_makefile_star2_O2/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 0x19b21
retq
pushq %rbx
movq %rdi, %rbx
testb $0x3, %cl
jne 0x19b3f
leaq 0x153a0(%rip), %rdi     # 0x2eed1
movq %rbx, %rsi
xorl %edx, %edx
callq 0x18788
movzwl 0x18(%rbx), %eax
xorl %edi, %edi
testb $0x3, %al
setne %dil
leaq 0x15379(%rip), %rsi     # 0x2eec7
callq 0x1225f
movzwl 0x18(%rbx), %eax
testb $0x1, %al
jne 0x19b62
movl $0x7fffffff, 0x1c(%rbx) # imm = 0x7FFFFFFF
testb $0x2, %al
jne 0x19b6d
movl $0x80000001, 0x20(%rbx) # imm = 0x80000001
testb $0x40, %al
je 0x19ba3
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
je 0x19ba3
testb $0x2, %al
jne 0x19b94
testb $0x1, %al
je 0x19ba3
andl $-0x44, %eax
orl $0x2, %eax
movw %ax, 0x18(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x20(%rbx)
jmp 0x19ba3
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_O2/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, %r15d
movq %rdi, %r14
testb $0x20, 0x18(%rdi)
pushq $0x1
popq %rbp
je 0x19bd1
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x19c97
movq %r14, %rdi
callq 0x19a5e
testl %eax, %eax
jne 0x19c97
movzwl 0x18(%r14), %eax
movzwl %ax, %ecx
testb $0x40, %cl
jne 0x19c22
testb $0x2, %cl
je 0x19bff
movl 0x20(%r14), %edx
testl %edx, %edx
js 0x19ca7
xorl %ecx, %ecx
testb $0x1, %al
je 0x19c59
movl 0x1c(%r14), %edx
cmpl %r15d, %edx
jle 0x19c59
decl %edx
decl %r15d
leaq 0x15228(%rip), %rsi     # 0x2ee42
movq %rsp, %rdi
movl %r15d, %ecx
jmp 0x19c72
movl %ecx, %edi
shrl %edi
andl %ecx, %edi
andl $0x1, %edi
leaq 0x15240(%rip), %rsi     # 0x2ee72
callq 0x1225f
movl 0x1c(%r14), %ecx
movl 0x20(%r14), %edx
leal -0x1(%rcx), %eax
cmpl %eax, %edx
jne 0x19c68
leaq 0x1523a(%rip), %rsi     # 0x2ee87
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3260
jmp 0x19c5d
testb %cl, %cl
jne 0x19c79
leaq 0x65d6c(%rip), %rax     # 0x7f9d0
incl (%rax)
jmp 0x19c97
leaq 0x15239(%rip), %rsi     # 0x2eea8
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3260
leaq 0x65d54(%rip), %rax     # 0x7f9d4
incl (%rax)
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x19c97
movq (%r14), %rdx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x122b2
movl %ebp, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15173(%rip), %rsi     # 0x2ee21
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3260
movzwl 0x18(%r14), %eax
movb $0x1, %cl
jmp 0x19c01
// File: /workspace/github_c_makefile_star2_O2/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 0x19d1f
movzwl 0x18(%rbx), %ecx
andl $0x4, %ecx
movzwl 0x18(%r14), %edx
andl $0x4, %edx
cmpw %dx, %cx
jne 0x19d1f
testw %cx, %cx
jne 0x19d1c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a79
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x65a73(%rip), %r14     # 0x7fa20
xorl %ecx, %ecx
cmpq $0x14, %rax
je 0x19fc3
cmpl $0x1, (%rax,%r14)
sbbl $-0x1, %ecx
addq $0x4, %rax
jmp 0x19faf
testl %ecx, %ecx
je 0x1a009
leaq 0x1546c(%rip), %rdi     # 0x2f43a
callq 0x30a0
leaq 0x1cd46(%rip), %r15     # 0x36d20
leaq 0x14f73(%rip), %rbx     # 0x2ef54
xorl %r12d, %r12d
cmpq $0x14, %r12
je 0x1a009
movl (%r12,%r14), %esi
testl %esi, %esi
je 0x19fff
movq (%r15), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3100
addq $0x4, %r12
addq $0x10, %r15
jmp 0x19fe4
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x14, %rax
je 0x1a021
cmpl $0x1, (%rax,%r14)
sbbl $-0x1, %ecx
addq $0x4, %rax
jmp 0x1a00d
testl %ecx, %ecx
je 0x1a06e
leaq 0x15431(%rip), %rdi     # 0x2f45d
callq 0x30a0
leaq 0x1cd58(%rip), %r14     # 0x36d90
leaq 0x65a01(%rip), %r15     # 0x7fa40
leaq 0x14f0e(%rip), %rbx     # 0x2ef54
xorl %r12d, %r12d
cmpq $0xc, %r12
je 0x1a06e
movl (%r12,%r15), %esi
testl %esi, %esi
je 0x1a064
movq (%r14), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3100
addq $0x4, %r12
addq $0x10, %r14
jmp 0x1a049
leaq 0x54e33(%rip), %rax     # 0x6eea8
movq (%rax), %rdi
callq 0x1a0ac
movl 0x659dd(%rip), %esi     # 0x7fa60
testl %esi, %esi
je 0x1a0a0
leaq 0x14ece(%rip), %rdi     # 0x2ef5c
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_O2/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 0x1a120
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1a11b
cmpw $0x0, 0x4a(%rbx)
jne 0x1a0f5
movq 0x8(%r15), %r14
leaq 0x14ff5(%rip), %rsi     # 0x2f0c8
movq %r14, %rdi
callq 0x3290
testq %rax, %rax
jne 0x1a0f5
movl 0x10(%r15), %edx
leaq 0x14fe5(%rip), %rdi     # 0x2f0d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3100
movw $0x1, 0x4a(%rbx)
addq $0x50, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1a11b
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a11b
callq 0x1a0ac
addq $0x18, %rbx
jmp 0x1a0ff
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %r14, %r14
je 0x1a574
movl 0x1c(%r14), %ecx
cmpl $0x2d, %ecx
je 0x1a557
cmpl $0x1, (%r14)
je 0x1a574
addl $-0x1f, %ecx
leaq 0x40(%r14), %rax
cmpl $0x2, %ecx
jbe 0x1a552
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1a50d
testl %eax, %eax
jne 0x1a572
addq $0x48, %r14
movq %r14, %rax
movq (%rax), %r14
jmp 0x1a51a
movq 0x40(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x3190
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x1a574
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1b545
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
jne 0x1b49f
movq 0x40(%r14), %r14
testq %r14, %r14
je 0x1b537
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x1b537
addq $0x18, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1b537
movl 0x4(%r15), %r12d
testl %ebp, %r12d
sete %al
testl %ebx, %r12d
setne %cl
orb %al, %cl
jne 0x1b52e
movq 0x64595(%rip), %r13     # 0x7fa68
movq (%r13), %r13
testq %r13, %r13
je 0x1b509
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
jne 0x1b503
cmpl %r12d, 0x10(%r13)
je 0x1b52e
addq $0x18, %r13
jmp 0x1b4d3
movq 0x8(%r15), %rdi
callq 0x12673
movq 0x6454f(%rip), %rcx     # 0x7fa68
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movl 0x4(%r15), %edx
movl %edx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rcx)
addq $0x10, %r15
jmp 0x1b4b0
addq $0x8, %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/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 0x1b61d
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 0x1b571
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x1b60f
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x1b60f
addq $0x18, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1b60f
movl 0x4(%r14), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
jne 0x1b606
xorl %r15d, %r15d
movq 0x644be(%rip), %r12     # 0x7fa68
movq %r12, %rax
movq (%rax), %r13
testq %r13, %r13
je 0x1b606
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
jne 0x1b5e8
movl 0x10(%r13), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
je 0x1b5f1
leaq 0x18(%r13), %rax
movq %r13, %r15
jmp 0x1b5ad
movq 0x18(%r13), %rax
testq %r15, %r15
je 0x1b600
movq %rax, 0x18(%r15)
jmp 0x1b5aa
movq %rax, (%r12)
jmp 0x1b5a3
addq $0x10, %r14
jmp 0x1b582
addq $0x8, %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/uno_generic.c
// Function: list_select
static void
list_select(treenode *n, int unused1, int unused2)
{	SymRef *s;
	SymList *r;
	int cnt = 0;

	if (n)
		printf("uno: %s:%d: symbols (*=selected):\n",
			n->hdr.fnm, n->hdr.line);
	else
		printf("uno: symbols (*=selected):\n");

	for (s = gen_stack->symrefs; s; s = s->nxt)
		{	printf("	%3d%s:\t%s [",
				++cnt,
				(s->status & SELECTED)?"*":"",
				s->sm->nme->str);
			dflow_mark(stdout, s->status);
			printf("]	(stack - mark %d)\n", s->s_val);
		}

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		{	printf("	%3d%s:	%s [",
				++cnt,
				r->selected?"*":"",
				r->sm->nme->str);
			dflow_mark(stdout, r->mark);
			printf("]	(stmnt)\n");
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
movq %rdi, (%rsp)
je 0x1b705
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %edx
leaq 0x1394f(%rip), %rdi     # 0x2f04b
xorl %eax, %eax
callq 0x3100
jmp 0x1b711
leaq 0x13d70(%rip), %rdi     # 0x2f47c
callq 0x30a0
pushq $0x1
popq %rbx
movq 0x6434d(%rip), %r13     # 0x7fa68
leaq 0x2a8d(%rip), %rbp      # 0x1e1af
leaq 0x13945(%rip), %r15     # 0x2f06e
movq 0x1b8a0(%rip), %r14     # 0x36fd0
leaq 0x13944(%rip), %r12     # 0x2f07b
movq (%r13), %r13
testq %r13, %r13
je 0x1b78e
btl $0x18, 0x10(%r13)
movq %rbp, %rdx
leaq 0x264b(%rip), %rax      # 0x1dd9b
cmovaeq %rax, %rdx
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
movq (%r14), %rdi
movl 0x10(%r13), %esi
callq 0xf4ab
movl 0x14(%r13), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3100
addq $0x18, %r13
incl %ebx
jmp 0x1b737
movq (%rsp), %rax
testq %rax, %rax
je 0x1b802
movq 0x28(%rax), %r13
testq %r13, %r13
je 0x1b802
addq $0x18, %r13
leaq 0x138c3(%rip), %r12     # 0x2f06e
leaq 0x13ce5(%rip), %r15     # 0x2f497
movq (%r13), %r13
testq %r13, %r13
je 0x1b802
cmpl $0x0, (%r13)
movq %rbp, %rdx
leaq 0x25d1(%rip), %rax      # 0x1dd9b
cmoveq %rax, %rdx
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq %r12, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
movq (%r14), %rdi
movl 0x4(%r13), %esi
callq 0xf4ab
movq %r15, %rdi
callq 0x30a0
addq $0x10, %r13
incl %ebx
jmp 0x1b7b2
addq $0x8, %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/uno_generic.c
// Function: sym_update
static void
sym_update(treenode *m, int val, int unused2)
{	SymRef *s;
	SymList *r;
	treenode *n;

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

	/* if any items on the stack were selected
	 * then a match() operations was executed
	 * which voids the select bits in defuse
	 */
	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
			goto after;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		if (r->selected)
		{	s = uno_getref(r->sm);
			s->nxt = gen_stack->symrefs;
			s->status = r->mark | SELECTED;
			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);
		}

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
		{	if (debug)
			printf("\tmarked %s = %d (line %d)\n",
				s->sm->nme->str, val, s->n?s->n->hdr.line:-1);
after:			s->s_val = val;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testq %rdi, %rdi
je 0x1b82e
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
jne 0x1b831
movq 0x40(%r14), %r14
jmp 0x1b831
xorl %r14d, %r14d
movq 0x64230(%rip), %rcx     # 0x7fa68
movq %rcx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1b84f
testb $0x1, 0x13(%rax)
jne 0x1b8b6
addq $0x18, %rax
jmp 0x1b83b
testq %r14, %r14
je 0x1b8a8
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x1b8a8
addq $0x18, %r15
movl $0x1000000, %ebp        # imm = 0x1000000
movq (%r15), %r15
testq %r15, %r15
je 0x1b8a1
cmpl $0x0, (%r15)
je 0x1b89b
movq 0x8(%r15), %rdi
callq 0x12673
movq 0x641e4(%rip), %rcx     # 0x7fa68
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movl 0x4(%r15), %edx
orl %ebp, %edx
movl %edx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rcx)
addq $0x10, %r15
jmp 0x1b866
movq 0x641c0(%rip), %rcx     # 0x7fa68
movq (%rcx), %rax
testq %rax, %rax
je 0x1b8c2
testb $0x1, 0x13(%rax)
je 0x1b8b9
movl %ebx, 0x14(%rax)
addq $0x18, %rax
movq %rax, %rcx
jmp 0x1b8a8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_unmark
static void
sym_unmark(treenode *unused0, int unused1, int unused2)
{	SymRef *s, *os = (SymRef *) 0;

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
		{	if (!os)
				gen_stack->symrefs = s->nxt;
			else
				os->nxt = s->nxt;

			if (debug) fprintf(stderr, "\tdeleted %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
		} else
			os = s;
}

// Assembly:
movq 0x64194(%rip), %rax     # 0x7fa68
xorl %ecx, %ecx
movq (%rax), %rax
testq %rax, %rax
je 0x1b90c
testb $0x1, 0x13(%rax)
movq %rax, %rdx
je 0x1b903
testq %rcx, %rcx
jne 0x1b8f5
movq 0x64175(%rip), %rdx     # 0x7fa68
jmp 0x1b8f9
leaq 0x18(%rcx), %rdx
movq 0x18(%rax), %rsi
movq %rsi, (%rdx)
movq %rcx, %rdx
addq $0x18, %rax
movq %rdx, %rcx
jmp 0x1b8d6
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: on_track
static int
on_track(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)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		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
				&&  (s->status & allow)
				&& !(s->status & forbid))
				{	if (m != s->n)
						witness = s->n;
					if (debug) printf("\tsym present %s (line %d)\n",
						r->sm->nme->str, s->n?s->n->hdr.line:-1);
					return 1;
		}	}	}

	if (debug)
	{	printf("on_track: no matching syms\n");
		if (n && n->hdr.defuse)
		for (r = n->hdr.defuse->other; r; r = r->nxt)
			printf("\tdefuse have %s %d\n", r->sm->nme->str, r->mark);
		for (s = gen_stack->symrefs; s; s = s->nxt)
			printf("\tgenstack have %s %d\n", s->sm->nme->str, s->status);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1b9db
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
movq %rdi, %rax
jne 0x1b941
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1b9db
movq 0x28(%rax), %r12
testq %r12, %r12
je 0x1b9db
addq $0x18, %r12
movq 0x6410f(%rip), %rax     # 0x7fa68
movq %rax, (%rsp)
movq (%r12), %r12
testq %r12, %r12
je 0x1b9db
movl 0x4(%r12), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1b9c2
movq (%rsp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1b9c2
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
jne 0x1b9bc
movl 0x10(%r13), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
je 0x1b9c8
addq $0x18, %r13
jmp 0x1b97e
addq $0x10, %r12
jmp 0x1b95d
movq 0x8(%r13), %rax
pushq $0x1
popq %rbx
cmpq %r14, %rax
je 0x1b9db
movq %rax, 0x640a5(%rip)     # 0x7fa80
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: any_track
static int
any_track(treenode *m, int allow, int forbid)
{	SymRef *s;

	for (s = gen_stack->symrefs; s; s = s->nxt)
	{	if ((s->status & allow)
		&& !(s->status & forbid))
		{	if (m != s->n)
				witness = s->n;
			if (debug) printf("\tanytrack sym present %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
			return 1;
	}	}

	if (debug) printf("any_track: no matching syms\n");
	return 0;
}

// Assembly:
movq 0x64075(%rip), %rax     # 0x7fa68
movq (%rax), %rax
testq %rax, %rax
je 0x1ba14
movl 0x10(%rax), %ecx
testl %esi, %ecx
sete %r8b
testl %edx, %ecx
setne %cl
orb %r8b, %cl
je 0x1ba17
addq $0x18, %rax
jmp 0x1b9f3
xorl %eax, %eax
retq
movq 0x8(%rax), %rcx
pushq $0x1
popq %rax
cmpq %rdi, %rcx
je 0x1ba2a
movq %rcx, 0x64056(%rip)     # 0x7fa80
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: match_track
static int
match_track(treenode *m, int allow, int forbid)
{	SymRef *s;
	SymList *r;
	treenode *n;	/* var with allow and !forbid on defuse - that is also on_track? */

	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))
		{	for (s = gen_stack->symrefs; s; s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0)
				{	if (m != s->n)
						witness = s->n;
					if (debug) printf("\tsym matched %s (line %d)\n",
						r->sm->nme->str, s->n?s->n->hdr.line:-1);
					return 1;
		}	}	}

	if (debug) printf("match_track: no matching syms\n");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1bae2
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
movq %rdi, %rax
jne 0x1ba5f
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1bae2
movq 0x28(%rax), %r12
testq %r12, %r12
je 0x1bae2
addq $0x18, %r12
movq 0x63ff5(%rip), %rax     # 0x7fa68
movq %rax, (%rsp)
movq (%r12), %r12
testq %r12, %r12
je 0x1bae2
movl 0x4(%r12), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1bac9
movq (%rsp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1bac9
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
je 0x1bacf
addq $0x18, %r13
jmp 0x1ba98
addq $0x10, %r12
jmp 0x1ba77
movq 0x8(%r13), %rax
pushq $0x1
popq %rbx
cmpq %r14, %rax
je 0x1bae2
movq %rax, 0x63f9e(%rip)     # 0x7fa80
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: good_target
static int
good_target(treenode *n, SymList *r)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT) return 1;

	if (n->hdr.type == TN_ASSIGN
	&&  n->lnode
	&&  n->lnode->hdr.type == TN_IDENT
	&&  strcmp(r->sm->nme->str, ((leafnode *) n->lnode)->data.sval->str) == 0)
		return 1;

	return 0;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1bdee
movl 0x1c(%rdi), %eax
pushq $0x1
popq %rbx
cmpl $0x2d, %eax
je 0x1bdee
cmpl $0x1c, %eax
jne 0x1bdec
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1bdec
cmpl $0x2d, 0x1c(%rax)
jne 0x1bdec
movq 0x8(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdi
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
je 0x1bdee
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: do_oper
static int
do_oper(treenode *m, int sign)
{	treenode *n;

	/* either --x (rnode) or x-- (lnode) */
	/* executed as stmnt, net effect the same */

	if (m->rnode) n = m->rnode; else n = m->lnode;

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

	gen_stack->uno_state += sign;

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x1c030
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1c05f
xorl %ebp, %ebp
cmpl $0x2d, 0x1c(%rax)
jne 0x1c061
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x1b171(%rip), %rsi     # 0x371b8
callq 0x3190
testl %eax, %eax
jne 0x1c061
movq 0x63a11(%rip), %rax     # 0x7fa68
addl %ebx, 0x8(%rax)
pushq $0x1
popq %rbp
jmp 0x1c061
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_matched
static int
err_matched(GenStack *g)
{
	if (!g) return 0;

	return err_matched(g->nxt)
	|| (witness
	&&  witness == g->e
	&&  v_matched(g->e));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1c088
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x1c06a
testl %eax, %eax
je 0x1c092
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x639e7(%rip), %rax     # 0x7fa80
testq %rax, %rax
je 0x1c088
movq 0x10(%r14), %rdi
cmpq %rdi, %rax
jne 0x1c088
callq 0x1871d
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
jmp 0x1c088
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_reversed
static void
err_reversed(GenStack *g)
{
	if (!g) return;

	if (!nopaths)
		err_reversed(g->nxt);
#if 0
	if (!debug && witness)
	{	if (g->e != witness)
			return;
		if (v_reported(g->e))
		{	fprintf(stderr, "\t--:\t%s:%d: <%s> matches an earlier case\n",
				g->e->hdr.fnm,
				g->e->hdr.line,
				x_stmnt(g->e));
			return;
		}
	}
	witness = ZT;
#endif

	if (g->e
	&&  g->e->hdr.type != TN_SWITCH
	&&  g->e->hdr.type != TN_WHILE
	&&  g->e->hdr.type != TN_DOWHILE)
	{
		if (g->e == witness) printf("*");
		if (g->c) printf("C");

		if (!nopaths) printf("\t%d:", steps++);

		printf("\t%s:%d: <%s>",
			g->e->hdr.fnm,
			g->e->hdr.line,
			x_stmnt(g->e));
		if (g->c)
			printf(" == <%s>", x_stmnt(g->c));

		if (debug) dump_defuse(g->e->hdr.defuse, stdout);
		printf(";\n");
	} else if (nopaths) err_reversed(g->nxt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1b0a9(%rip), %r14     # 0x3716c
testq %rbx, %rbx
je 0x1c0f7
cmpl $0x0, (%r14)
jne 0x1c0d7
movq 0x20(%rbx), %rdi
callq 0x1c0b5
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1c0eb
movl 0x1c(%rax), %ecx
addl $-0x1f, %ecx
cmpl $0x3, %ecx
jae 0x1c0fc
cmpl $0x0, (%r14)
je 0x1c0f7
movq 0x20(%rbx), %rbx
jmp 0x1c0c3
popq %rbx
popq %r14
popq %rbp
retq
cmpq 0x6397d(%rip), %rax     # 0x7fa80
jne 0x1c10d
pushq $0x2a
popq %rdi
callq 0x3040
cmpq $0x0, 0x18(%rbx)
je 0x1c11c
pushq $0x43
popq %rdi
callq 0x3040
cmpl $0x0, (%r14)
jne 0x1c13f
movl 0x6396c(%rip), %esi     # 0x7fa94
leal 0x1(%rsi), %eax
movl %eax, 0x63963(%rip)     # 0x7fa94
leaq 0x132c9(%rip), %rdi     # 0x2f401
xorl %eax, %eax
callq 0x3100
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %ebp
callq 0x4ac7
leaq 0x132b0(%rip), %rdi     # 0x2f406
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3100
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1c184
callq 0x4ac7
leaq 0x13299(%rip), %rdi     # 0x2f413
movq %rax, %rsi
xorl %eax, %eax
callq 0x3100
leaq 0x1233c(%rip), %rdi     # 0x2e4c7
popq %rbx
popq %r14
popq %rbp
jmp 0x30a0