LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b28d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x2b29a
movq $0x0, -0x8(%rbp)
jmp 0x2b360
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2b321
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2b317
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2b315
callq 0x3250
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x2b313
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b360
jmp 0x2b2bd
jmp 0x2b317
movq $0x0, -0x8(%rbp)
jmp 0x2b360
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2b270
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2b34f
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b360
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2b270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b38f
movl $0x0, -0x4(%rbp)
jmp 0x2b457
movq -0x10(%rbp), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x2b3f7
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x131, %eax            # imm = 0x131
je 0x2b3e5
jmp 0x2b3ac
movl -0x14(%rbp), %eax
addl $0xfffffec9, %eax       # imm = 0xFFFFFEC9
subl $0x4, %eax
jb 0x2b3e5
jmp 0x2b3bb
movl -0x14(%rbp), %eax
addl $0xfffffeb0, %eax       # imm = 0xFFFFFEB0
subl $0x2, %eax
jb 0x2b3e5
jmp 0x2b3ca
movl -0x14(%rbp), %eax
addl $0xfffffea9, %eax       # imm = 0xFFFFFEA9
subl $0x2, %eax
jb 0x2b3e5
jmp 0x2b3d9
movl -0x14(%rbp), %eax
subl $0x162, %eax            # imm = 0x162
jne 0x2b3ee
jmp 0x2b3e5
movl $0x1, -0x4(%rbp)
jmp 0x2b457
movl $0x0, -0x4(%rbp)
jmp 0x2b457
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2b414
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x2b414
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2b41d
movl $0x0, -0x4(%rbp)
jmp 0x2b457
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2b370
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x2b44c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2b370
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b47f
movl $0x0, -0x4(%rbp)
jmp 0x2b4e6
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x2b494
movl $0x1, -0x4(%rbp)
jmp 0x2b4e6
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2b4a6
movl $0x0, -0x4(%rbp)
jmp 0x2b4e6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x2b460
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x2b4db
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x2b460
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x6b27d(%rip), %rax     # 0x96b00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b8b4
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2b8a4
movl $0x1, -0x4(%rbp)
jmp 0x2b8dd
jmp 0x2b8a6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b887
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x1fd20
cmpl $0x0, %eax
je 0x2b8d6
movl $0x1, -0x4(%rbp)
jmp 0x2b8dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b870
cmpl $0x0, %eax
je 0x2b913
movl $0x1, -0x4(%rbp)
jmp 0x2b94d
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x6b1cd(%rip), %rcx     # 0x96b00
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x6b1ba(%rip)     # 0x96b00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: ana_aio_decl
static void
ana_aio_decl(SymList *s, treenode *tn, treenode *nn)
{
	if (!tn) return;

	if (tn->hdr.type == TN_DECL
	&&  tn->rnode
	&&  tn->lnode
	&&  tn->lnode->hdr.type == TN_PNTR)
	{	ana_aio_decl(s, tn->rnode, nn);
		return;
	}

	if (tn->hdr.type == TN_ARRAY_DECL
	&&  tn->lnode->hdr.type == TN_IDENT	/* the index: the array size */
	&&  tn->lnode->syment == s->sm)
	{	add_size(s->sm, tn->rnode, nn);
		if (debug>1)
		{	printf("uno: set bound ana_aio for %s\n",
				s->sm->nme->str);
			printf("uno: %s:%d basename %s",
				tn->hdr.fnm,
				tn->hdr.line,
				x_stmnt(tn->lnode));
			printf("[ %s ]\t",
				x_stmnt(tn->rnode));
			printf("=====%s\n\t", name_of_node(nn->hdr.type));
			print_recur(nn, stdout);
			printf("\n");
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2bda0
jmp 0x2beff
movq -0x10(%rbp), %rax
cmpl $0x5, 0x1c(%rax)
jne 0x2bde8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2bde8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2bde8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x13, 0x1c(%rax)
jne 0x2bde8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2bd80
jmp 0x2beff
movq -0x10(%rbp), %rax
cmpl $0x6, 0x1c(%rax)
jne 0x2beff
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2beff
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2beff
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2cc60
cmpl $0x1, 0x6ad16(%rip)     # 0x96b58
jle 0x2befd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1a82c(%rip), %rdi     # 0x4668b
movb $0x0, %al
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4ec0
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq %rax, %rcx
leaq 0x1a810(%rip), %rdi     # 0x466aa
movb $0x0, %al
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x4ec0
movq %rax, %rsi
leaq 0x1a809(%rip), %rdi     # 0x466c1
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x8270
movq %rax, %rsi
leaq 0x1a7f4(%rip), %rdi     # 0x466c9
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rdi
movq 0x220e9(%rip), %rax     # 0x4dfd0
movq (%rax), %rsi
callq 0x1f900
leaq 0x18849(%rip), %rdi     # 0x4473f
movb $0x0, %al
callq 0x30f0
jmp 0x2beff
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_index
void
uno_index(State *s)
{	ArList *a;
	treenode *e;

	if (!s) return;

	if (s->n && s->n->hdr.type == TN_IF)
		e = ((if_node *)s->n)->cond;
	else
		e = s->n;

	if (e && e->hdr.defuse)
	for (a = e->hdr.defuse->aio; a; a = a->nxt)		/* index operations */
		ana_aio_ix(s, a->tn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2bf25
jmp 0x2bfa1
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2bf4d
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1b, 0x1c(%rax)
jne 0x2bf4d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2bf58
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2bfa1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2bfa1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bf9f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2bfb0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2bf7a
jmp 0x2bfa1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x6a595(%rip), %rdi     # 0x96b40
callq 0x2c5f0
movq %rax, 0x6a589(%rip)     # 0x96b40
movq 0x6a58a(%rip), %rdi     # 0x96b48
callq 0x2c640
movq %rax, 0x6a57e(%rip)     # 0x96b48
movq 0x6a57f(%rip), %rdi     # 0x96b50
callq 0x2c640
movq %rax, 0x6a573(%rip)     # 0x96b50
movq $0x0, 0x6a518(%rip) # 0x96b00
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c62a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2c5f0
movq 0x6a559(%rip), %rcx     # 0x96b70
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x6a546(%rip)     # 0x96b70
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c67a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2c640
movq 0x6a4f9(%rip), %rcx     # 0x96b60
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x6a4e6(%rip)     # 0x96b60
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: bound_pop
static void
bound_pop(void)
{	BoundStack *f;

	uno_assert((boundstack != NULL), "boundstack pop error");
	uno_dumpbounds(boundstack->curbounds);	/* recycle */

	f = boundstack;
	boundstack = boundstack->nxt;		/* pop */

	f->nxt = freestack;			/* recycle */
	freestack = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x69f68(%rip)     # 0x96b68
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x19f4f(%rip), %rsi     # 0x46b5e
callq 0x1fde0
movq 0x69f4d(%rip), %rax     # 0x96b68
movq (%rax), %rdi
callq 0x2c5f0
movq 0x69f3e(%rip), %rax     # 0x96b68
movq %rax, -0x8(%rbp)
movq 0x69f33(%rip), %rax     # 0x96b68
movq 0x8(%rax), %rax
movq %rax, 0x69f28(%rip)     # 0x96b68
movq 0x69f31(%rip), %rcx     # 0x96b78
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x69f1e(%rip)     # 0x96b78
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: add_size
static void
add_size(symentry_t *s, treenode *b, treenode *n)
{	ArSize *a;
	int cnt;
	leafnode *q;

	for (a = arsize; a; a = a->nxt)
		if (a->s == s)
			return;

	if (!b)
	{	if ((cnt = find_ininode(s, n)) != 0)
		{	size_zero_resolved++;
			if (Verbose || debug > 1)
			printf("uno:	bound for array %s\tresolved: %d\n",
				s->nme->str, cnt);
			q = (leafnode *) emalloc(sizeof(leafnode));
			q->hdr.which = LEAF_T;
			q->hdr.type = TN_INT;
			q->data.ival = cnt;
			b = (treenode *) q;
		} else
		{	size_zero++;
			if (Verbose || debug > 1)
			printf("uno:	bound for array %s\tnot resolved\n", s->nme->str);
			return;
		}
	}

	if (Verbose>1) 
	printf("uno: %s:%d have array bound for %s\n",
		n->hdr.fnm,
		n->hdr.line,
		s->nme->str);

	a = getars();
	a->s = s;
	a->b = b;
	a->nxt = arsize;
	arsize = a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x69ecd(%rip), %rax     # 0x96b48
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2cca8
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x2cc98
jmp 0x2cdf1
jmp 0x2cc9a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2cc7f
cmpq $0x0, -0x10(%rbp)
jne 0x2cd82
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ce00
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x2cd40
movl 0x69e3a(%rip), %eax     # 0x96b08
addl $0x1, %eax
movl %eax, 0x69e31(%rip)     # 0x96b08
leaq 0x2169a(%rip), %rax     # 0x4e378
cmpl $0x0, (%rax)
jne 0x2ccec
cmpl $0x1, 0x69e6e(%rip)     # 0x96b58
jle 0x2cd09
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movl -0x24(%rbp), %edx
leaq 0x199d1(%rip), %rdi     # 0x466d3
movb $0x0, %al
callq 0x30f0
movl $0x48, %edi
callq 0x54c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movl $0x30, 0x1c(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2cd80
movl 0x69dc6(%rip), %eax     # 0x96b0c
addl $0x1, %eax
movl %eax, 0x69dbd(%rip)     # 0x96b0c
leaq 0x21622(%rip), %rax     # 0x4e378
cmpl $0x0, (%rax)
jne 0x2cd64
cmpl $0x1, 0x69df6(%rip)     # 0x96b58
jle 0x2cd7e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x19982(%rip), %rdi     # 0x466f9
movb $0x0, %al
callq 0x30f0
jmp 0x2cdf1
jmp 0x2cd82
leaq 0x215ef(%rip), %rax     # 0x4e378
cmpl $0x1, (%rax)
jle 0x2cdb7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x1996f(%rip), %rdi     # 0x4671f
movb $0x0, %al
callq 0x30f0
callq 0x2ceb0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x69d6a(%rip), %rcx     # 0x96b48
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x69d57(%rip)     # 0x96b48
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2ce20
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2ce29
movl $0x0, -0x4(%rbp)
jmp 0x2ce98
movq -0x18(%rbp), %rax
cmpl $0x1c, 0x1c(%rax)
jne 0x2ce69
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x17, 0x1c(%rax)
jne 0x2ce69
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x2cf10
cmpl $0x0, %eax
je 0x2ce69
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2cfa0
movl %eax, -0x4(%rbp)
jmp 0x2ce98
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x2ce00
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2ce00
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x69ca0(%rip)     # 0x96b60
je 0x2cef1
movq 0x69c97(%rip), %rax     # 0x96b60
movq %rax, -0x8(%rbp)
movq 0x69c8c(%rip), %rax     # 0x96b60
movq 0x10(%rax), %rax
movq %rax, 0x69c81(%rip)     # 0x96b60
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3140
jmp 0x2ceff
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x6, 0x1c(%rax)
jne 0x2cf53
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2cf53
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2cf53
movl $0x1, -0x4(%rbp)
jmp 0x2cf91
movq -0x18(%rbp), %rax
cmpl $0x5, 0x1c(%rax)
jne 0x2cf8a
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x13, 0x1c(%rax)
jne 0x2cf8a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2cf10
cmpl $0x0, %eax
je 0x2cf8a
movl $0x1, -0x4(%rbp)
jmp 0x2cf91
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2cfbc
movl $0x0, -0x4(%rbp)
jmp 0x2d010
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2cfe9
movq -0x10(%rbp), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2cfe0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x20590
movl $0x1, -0x4(%rbp)
jmp 0x2d010
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2cfa0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2cfa0
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: eval_cond
static int
eval_cond(treenode *a, treenode *b)	/* is a < b ? */
{	int ix, bnd;
	nogood = 0;

	ix  = eval_const_expr(a, ZT);

	if (ix < 0) return 0;		/* definitely wrong */

	bnd = eval_const_expr(b, ZT);

	if (nogood) return -2;		/* can't tell */

	if (ix == bnd) return -1;	/* equal to bound */

	return (ix < bnd);	/* satisfied */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, 0x698be(%rip)     # 0x96af8
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b4f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2d259
movl $0x0, -0x4(%rbp)
jmp 0x2d29d
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b4f0
movl %eax, -0x20(%rbp)
cmpl $0x0, 0x69888(%rip)     # 0x96af8
je 0x2d27b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2d29d
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x2d28c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d29d
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_bframe
static BoundStack *
uno_bframe(void)
{	BoundStack *f;

	if (freestack)
	{	f = freestack;
		freestack = freestack->nxt;
		f->nxt = (BoundStack *) 0;
	} else
		f = (BoundStack *) emalloc(sizeof(BoundStack));
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x698b8(%rip)     # 0x96b78
je 0x2d2ed
movq 0x698af(%rip), %rax     # 0x96b78
movq %rax, -0x8(%rbp)
movq 0x698a4(%rip), %rax     # 0x96b78
movq 0x8(%rax), %rax
movq %rax, 0x69899(%rip)     # 0x96b78
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2d2fb
movl $0x10, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x195dc(%rip), %rsi     # 0x46915
callq 0x1fde0
callq 0x2de20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: dual_work
static void
dual_work(State *z)
{	SymList *s;
	leafnode *l;
	ArBound *b;
	treenode *n;

	if (!z) return;

	n = z->n;

	if (!n || !n->hdr.defuse)
		return;

	l = leftmost(n);
	if (l && l->hdr.tok == EXTRN)
		return;	

	for (s = n->hdr.defuse->other; s; s = s->nxt)
	{
		if ((s->sm->decl_level >= FUNCTION_SCOPE)	/* local */
		&&  (s->mark & DECL)				/* declaration */
		&&  (s->mark & DEF)				/* with initializer */
		&& !(s->mark & ARRAY_DECL)			/* not array decl */
		&& !uno_ignore(s->sm)				/* not from /usr/include */
		&& !(s->mark & REF2))				/* not compound x->ref2 or x.ref2 */
		{	b = uno_dig(s->sm, n);			/* try to derive initial bounds on var */
			if (debug>1)
			explain_bound("newbound", b, n);
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d398
jmp 0x2d4a9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2d3b5
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x2d3ba
jmp 0x2d4a9
movq -0x28(%rbp), %rdi
callq 0x7d60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d3e0
movq -0x18(%rbp), %rax
cmpl $0x118, 0x18(%rax)      # imm = 0x118
jne 0x2d3e0
jmp 0x2d4a9
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d4a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movswl 0x20(%rax), %eax
cmpl $0x3, %eax
jl 0x2d496
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x2d496
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2d496
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x2d496
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1fe30
cmpl $0x0, %eax
jne 0x2d496
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x2d496
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2dea0
movq %rax, -0x20(%rbp)
cmpl $0x1, 0x696da(%rip)     # 0x96b58
jle 0x2d494
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x1949d(%rip), %rdi     # 0x4692c
callq 0x2b960
jmp 0x2d496
jmp 0x2d498
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d3f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: expr_bound
static void
expr_bound(treenode *n, treenode *v)		/* try to derive bounds on scalars from cond */
{	ArBound *b = (ArBound *) 0;
	char *s;

	if (!n || !v) return;	/* branch conditions only */

	if (n && n->hdr.type == TN_EXPR)
		b = bound_from_expr(n);
	if (!b) return;

	if (v->hdr.tok == IDENT)
	{	s = ((leafnode *)v)->data.sval->str;

		if (strcmp(s, "_false_") == 0)
		{	if (debug>1)
			printf("	negating bound\n");

			negate_bound(b);
		} else if (strcmp(s,  "_true_") != 0)
			goto not_yet;
	} else
	{	/* remove bound b from bounded */
not_yet:
		if (debug>1)
		{	printf("uno: complex condition, removing last derived bound\n");
			explain_bound("expr_bound", b, n);
		}
		uno_assert((int) (b == bounded), "exprbound error");
		bounded = bounded->nxt;

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

	if (debug>1)
	explain_bound("expr_bound", b, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2d4d6
cmpq $0x0, -0x10(%rbp)
jne 0x2d4db
jmp 0x2d60b
cmpq $0x0, -0x8(%rbp)
je 0x2d4f9
movq -0x8(%rbp), %rax
cmpl $0x28, 0x1c(%rax)
jne 0x2d4f9
movq -0x8(%rbp), %rdi
callq 0x2e1a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2d505
jmp 0x2d60b
movq -0x10(%rbp), %rax
cmpl $0x102, 0x18(%rax)      # imm = 0x102
jne 0x2d574
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x17b71(%rip), %rsi     # 0x4509e
callq 0x3160
cmpl $0x0, %eax
jne 0x2d559
cmpl $0x1, 0x6961a(%rip)     # 0x96b58
jle 0x2d54e
leaq 0x19448(%rip), %rdi     # 0x4698f
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x2e310
jmp 0x2d572
movq -0x20(%rbp), %rdi
leaq 0x17b42(%rip), %rsi     # 0x450a6
callq 0x3160
cmpl $0x0, %eax
je 0x2d570
jmp 0x2d576
jmp 0x2d572
jmp 0x2d5ee
jmp 0x2d576
cmpl $0x1, 0x695db(%rip)     # 0x96b58
jle 0x2d5a1
leaq 0x1941a(%rip), %rdi     # 0x469a0
movb $0x0, %al
callq 0x30f0
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x19439(%rip), %rdi     # 0x469d5
callq 0x2b960
movq -0x18(%rbp), %rax
cmpq 0x69594(%rip), %rax     # 0x96b40
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x19425(%rip), %rsi     # 0x469e0
callq 0x1fde0
movq 0x69579(%rip), %rax     # 0x96b40
movq 0x28(%rax), %rax
movq %rax, 0x6956e(%rip)     # 0x96b40
movq 0x69597(%rip), %rcx     # 0x96b70
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x69584(%rip)     # 0x96b70
jmp 0x2d60b
cmpl $0x1, 0x69563(%rip)     # 0x96b58
jle 0x2d60b
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x193cf(%rip), %rdi     # 0x469d5
callq 0x2b960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: asgn_bound
static void
asgn_bound(State *s)		/* try to derive bounds on scalars from asgn */
{	ArBound *b = (ArBound *) 0;
	treenode *n;

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

	if (n
	&&  n->hdr.type == TN_ASSIGN
	&&  n->hdr.tok == EQ)
		b = bound_from_asgn((symentry_t *)0, n);

	if (debug>1)
	explain_bound("asgn_bound", b, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d63d
jmp 0x2d694
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d677
movq -0x18(%rbp), %rax
cmpl $0x1c, 0x1c(%rax)
jne 0x2d677
movq -0x18(%rbp), %rax
cmpl $0x14b, 0x18(%rax)      # imm = 0x14B
jne 0x2d677
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2df30
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x694da(%rip)     # 0x96b58
jle 0x2d694
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x19361(%rip), %rdi     # 0x469f0
callq 0x2b960
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: uno_freshbound
static ArBound *
uno_freshbound(void)
{	ArBound *b;

	if (freebounds)
	{	b = freebounds;
		freebounds = freebounds->nxt;
		b->sameas = (symentry_t *) 0;
		b->dup = (ArBound *) 0;
		b->nxt = (ArBound *) 0;
	} else
		b = (ArBound *) emalloc(sizeof(ArBound));

	b->level_set = depth;
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x68d40(%rip)     # 0x96b70
je 0x2de75
movq 0x68d37(%rip), %rax     # 0x96b70
movq %rax, -0x8(%rbp)
movq 0x68d2c(%rip), %rax     # 0x96b70
movq 0x28(%rax), %rax
movq %rax, 0x68d21(%rip)     # 0x96b70
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x2de83
movl $0x30, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
leaq 0x5810e(%rip), %rax     # 0x85f98
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x5, %eax
je 0x2def0
jmp 0x2dec9
movl -0x1c(%rbp), %eax
subl $0x10, %eax
je 0x2def0
jmp 0x2ded3
movl -0x1c(%rbp), %eax
subl $0x1c, %eax
jne 0x2df23
jmp 0x2dedd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2df30
movq %rax, -0x18(%rbp)
jmp 0x2df25
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x2dea0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2df21
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2dea0
movq %rax, -0x18(%rbp)
jmp 0x2df23
jmp 0x2df25
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2df81
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2df81
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2df81
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x2df8e
cmpq $0x0, -0x10(%rbp)
je 0x2df8e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e054
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
jne 0x2dfe2
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
cmpq 0x38(%rcx), %rax
je 0x2dfe0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rdi
xorl %edx, %edx
movl $0x28, %ecx
movl %edx, %esi
callq 0x2e060
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2e02e
movl $0x0, 0x68b0c(%rip)     # 0x96af8
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b4f0
movl %eax, -0x24(%rbp)
cmpl $0x0, 0x68af1(%rip)     # 0x96af8
jne 0x2e02c
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rdi
movl -0x24(%rbp), %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl $0xb, %ecx
callq 0x2e060
movq %rax, -0x20(%rbp)
jmp 0x2e02e
cmpl $0x0, 0x68b23(%rip)     # 0x96b58
je 0x2e04c
cmpq $0x0, -0x20(%rbp)
je 0x2e04c
leaq 0x188f0(%rip), %rdi     # 0x46935
movb $0x0, %al
callq 0x30f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e089
movq $0x0, -0x8(%rbp)
jmp 0x2e18f
movq 0x68ab0(%rip), %rax     # 0x96b40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e157
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2e144
movq -0x28(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x2e144
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2e103
cmpl $0x1, 0x68a82(%rip)     # 0x96b58
jle 0x2e0f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x18868(%rip), %rdi     # 0x46953
movb $0x0, %al
callq 0x30f0
movq -0x28(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x18(%rax)
jmp 0x2e142
movq -0x28(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2e140
cmpl $0x1, 0x68a3e(%rip)     # 0x96b58
jle 0x2e136
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1883e(%rip), %rdi     # 0x4696d
movb $0x0, %al
callq 0x30f0
movq $0x0, -0x8(%rbp)
jmp 0x2e18f
jmp 0x2e142
jmp 0x2e144
jmp 0x2e146
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2e094
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2d310
movq %rax, -0x28(%rbp)
movq 0x689cc(%rip), %rcx     # 0x96b40
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq %rax, 0x689b9(%rip)     # 0x96b40
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_bounds.c
// Function: bound_from_expr
static ArBound *
bound_from_expr(treenode *nn)
{	ArBound *b = (ArBound *) 0;
	symentry_t *s;
	int n;

	if (!nn
	||  !nn->lnode
	||   nn->lnode->hdr.type != TN_IDENT)
		return (ArBound *) 0;

	nogood = 0;
	n = eval_const_expr(nn->rnode, ZT);
	if (nogood)
		return (ArBound *) 0;

	s = nn->lnode->syment;

	switch (nn->hdr.tok) {
	case EQUAL:
		b = add_bound(s, n, n+1, LB|UB|FROMEXPR);
		break;
	case NOT_EQ:
		b = add_bound(s, n, n+1, LB|UB|NEG|FROMEXPR);
		break;
	case LESS:
		b = add_bound(s, 0, n, UB|FROMEXPR);
		break;
	case LESS_EQ:
		b = add_bound(s, 0, n+1, UB|FROMEXPR);
		break;
	case GRTR:
		b = add_bound(s, n+1, 0, LB|FROMEXPR);
		break;
	case GRTR_EQ:
		b = add_bound(s, n, 0, LB|FROMEXPR);
		break;
	}

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2e1d4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2e1d4
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2d, 0x1c(%rax)
je 0x2e1e1
movq $0x0, -0x8(%rbp)
jmp 0x2e301
movl $0x0, 0x6890d(%rip)     # 0x96af8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b4f0
movl %eax, -0x24(%rbp)
cmpl $0x0, 0x688f2(%rip)     # 0x96af8
je 0x2e215
movq $0x0, -0x8(%rbp)
jmp 0x2e301
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0xfffffec9, %eax       # imm = 0xFFFFFEC9
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x21, %eax
ja 0x2e2f9
movq -0x30(%rbp), %rax
leaq 0x180cd(%rip), %rcx     # 0x46318
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl $0x13, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
jmp 0x2e2f9
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl $0x53, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
jmp 0x2e2f9
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
xorl %esi, %esi
movl $0x11, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
jmp 0x2e2f9
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
addl $0x1, %edx
xorl %esi, %esi
movl $0x11, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
jmp 0x2e2f9
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
xorl %edx, %edx
movl $0x12, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
jmp 0x2e2f9
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %edx, %edx
movl $0x12, %ecx
callq 0x2e060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x6885d(%rip)     # 0x96b80
jle 0x2e339
movq -0x8(%rbp), %rsi
leaq 0x18843(%rip), %rdi     # 0x46b73
xorl %eax, %eax
movl %eax, %edx
callq 0x2b960
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x24, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x18824(%rip), %rsi     # 0x46b7c
callq 0x1fde0
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e3b2
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e3b2
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x2e39e
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x18(%rax)
jmp 0x2e3ad
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0x18(%rax)
jmp 0x2e44a
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e3f0
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x3, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x2e448
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e42e
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x2, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x2e446
leaq 0x1875c(%rip), %rdi     # 0x46b91
movb $0x0, %al
callq 0x30f0
movl $0x1, %edi
callq 0x3230
jmp 0x2e448
jmp 0x2e44a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x2e6ac
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2e6b1
jmp 0x2e827
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x2e6e5
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2e6e5
movq -0x8(%rbp), %rsi
leaq 0x185b1(%rip), %rdi     # 0x46c8d
xorl %eax, %eax
movl %eax, %edx
callq 0x2b960
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $0x2, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x2e70e
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x18566(%rip), %rsi     # 0x46c83
callq 0x1fde0
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2e73d
movq -0x8(%rbp), %rax
movl $0x7fffffff, 0x1c(%rax) # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x2e758
movq -0x8(%rbp), %rax
movl $0x80000001, 0x20(%rax) # imm = 0x80000001
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x2e788
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e78d
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e78d
jmp 0x2e827
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e7da
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x3, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x2e827
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e825
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movswl 0x18(%rax), %ecx
orl $0x2, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x2e827
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x2eb42
movq -0x10(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x4, %eax
movq -0x18(%rbp), %rcx
movswl 0x18(%rcx), %ecx
andl $0x4, %ecx
cmpl %ecx, %eax
je 0x2eb4b
movl $0x0, -0x4(%rbp)
jmp 0x2eb74
movq -0x10(%rbp), %rax
movswl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2eb64
movl $0x1, -0x4(%rbp)
jmp 0x2eb74
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e4c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_intervals.c
// Function: copy_bound
static void
copy_bound(ArBound *to, ArBound *from)
{
	to->s       = from->s;
	to->sameas = from->sameas;
	to->dup    = from->dup;
	to->bounds = from->bounds;
	to->lb     = from->lb;
	to->ub     = from->ub;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movw 0x18(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
popq %rbp
retq
nopl (%rax,%rax)