LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_proposition
void
ax_proposition(FILE *fd, Ax_Props *p)
{
	if (p->t == 0)
	{	fprintf(fd, "c_code {	/* assert_r */\n");
		fprintf(fd, "	int _nq%d_(void) { return !(%s); }\n",
			p->nr, p->terms[0]);
		fprintf(fd, "	int _q%d_(void) { return (%s); }\n}\n",
			p->nr, p->terms[0]);
	} else
	{	fprintf(fd, "c_code {	/* assert_p */\n");
		fprintf(fd, "	int _q%d_(void) { return (%s); }\n",
			p->nr, p->terms[0]);
		fprintf(fd, "	int _r%d_(void) { return (%s); }\n}\n",
			p->nr, p->terms[1]);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x1485e
leaq 0x109df(%rip), %rdi     # 0x25201
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x109d7(%rip), %rsi     # 0x2521a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
movl 0x4(%r14), %edx
movq 0x18(%r14), %rcx
leaq 0x109e1(%rip), %rsi     # 0x2523d
jmp 0x1489f
leaq 0x10939(%rip), %rdi     # 0x2519e
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x10931(%rip), %rsi     # 0x251b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41d0
movl 0x4(%r14), %edx
movq 0x10(%r14), %rcx
leaq 0x1093d(%rip), %rsi     # 0x251dc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_fixed
void
ax_fixed(FILE *fd)
{
	fprintf(fd, "bool _ax_runs;\n");
	fprintf(fd, "c_code {\n");
	fprintf(fd, "	int (*_ax_q)(void), (*_ax_r)(void);\n\n");
	fprintf(fd, "	void _ax_start(int (*q)(void), int (*r)(void))\n");
	fprintf(fd, "	{	_ax_q = q;\n");
	fprintf(fd, "		_ax_r = r;\n");
	fprintf(fd, "		now._ax_runs = 1;\n");
	fprintf(fd, "}	}\n\n");
	fprintf(fd, "never {\n");
	fprintf(fd, "start:	/* assert_p(q,r) or ![](p -> (q U r)) */\n");
	fprintf(fd, "	do\n");
	fprintf(fd, "	:: c_expr { now._ax_runs && !_ax_r() } -> break\n");
	fprintf(fd, "	:: else\n");
	fprintf(fd, "	od;\n");
	fprintf(fd, "accept:\n");
	fprintf(fd, "	do\n");
	fprintf(fd, "	:: c_expr {  _ax_r() } -> _ax_runs = 0; goto start\n");
	fprintf(fd, "	:: c_expr { !_ax_r() && !_ax_q() } -> break	/* safety */\n");
	fprintf(fd, "	:: else						/* liveness */\n");
	fprintf(fd, "	od\n");
	fprintf(fd, "}\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x109a4(%rip), %rdi     # 0x25262
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0xfa99(%rip), %rdi      # 0x24370
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10982(%rip), %rdi     # 0x25272
movl $0x26, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10990(%rip), %rdi     # 0x25299
movl $0x30, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x109a8(%rip), %rdi     # 0x252ca
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1099e(%rip), %rdi     # 0x252d9
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10993(%rip), %rdi     # 0x252e7
movl $0x14, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1098f(%rip), %rdi     # 0x252fc
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1097c(%rip), %rdi     # 0x25302
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1096c(%rip), %rdi     # 0x2530b
movl $0x30, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10984(%rip), %r14     # 0x2533c
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42c0
leaq 0x1096d(%rip), %rdi     # 0x25341
movl $0x31, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10986(%rip), %rdi     # 0x25373
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10977(%rip), %rdi     # 0x2537d
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10964(%rip), %rdi     # 0x25383
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x42c0
leaq 0x1093f(%rip), %rdi     # 0x2538c
movl $0x34, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1095b(%rip), %rdi     # 0x253c1
movl $0x3a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x1097d(%rip), %rdi     # 0x253fc
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x10982(%rip), %rdi     # 0x2541a
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
leaq 0x111ee(%rip), %rdi     # 0x25c9f
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: ax_decorate
static void
ax_decorate(scopetab_t *that, treenode *n)	/* set n->syment on all TN_IDENT leafs */
{	leafnode *m;

	if (!n) return;

	if (n->hdr.type != TN_IDENT)
	{	ax_decorate(that, n->lnode);
		ax_decorate(that, n->rnode);
	}
	m = (leafnode *) n;

	if (m->hdr.which == LEAF_T
	&&  m->hdr.type  == TN_IDENT)
	{	symentry_t *old = m->syment;

		m->syment = find_glob_symentry(that, m->data.sval->str);

		if (!old)
		{	printf("old symentry not set\n");
same:			printf("new:\t%s symtable entry for glob::%s\n",
				m->syment?"found":"missing",
				m->data.sval->str);
		} else if (m->syment != old)
		{	printf("new symentry differs from old:\n");
			printf("old:\t%s symtable entry for glob::%s\n",
				m->syment?"found":"missing",
				m->data.sval->str);
			goto same;
		} else
		{	printf("old and new both set and equal\n");
			goto same;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x14b64
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2d, 0x1c(%rsi)
je 0x14afc
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x14aca
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x14aca
cmpl $0x1, (%rbx)
jne 0x14b64
cmpl $0x2d, 0x1c(%rbx)
jne 0x14b64
movq 0x28(%rbx), %r15
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x694d
movq %rax, 0x28(%rbx)
testq %r15, %r15
je 0x14b6a
cmpq %r15, %rax
je 0x14b73
leaq 0x1181b(%rip), %rdi     # 0x2634b
callq 0x40d0
cmpq $0x0, 0x28(%rbx)
leaq 0x11799(%rip), %rax     # 0x262da
leaq 0x14be4(%rip), %rsi     # 0x2972c
cmoveq %rax, %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdx
leaq 0x11787(%rip), %rdi     # 0x262e2
xorl %eax, %eax
callq 0x4140
jmp 0x14b7f
popq %rbx
popq %r14
popq %r15
retq
leaq 0x117a6(%rip), %rdi     # 0x26317
jmp 0x14b7a
leaq 0x117b2(%rip), %rdi     # 0x2632c
callq 0x40d0
cmpq $0x0, 0x28(%rbx)
leaq 0x1174f(%rip), %rax     # 0x262da
leaq 0x14b9a(%rip), %rsi     # 0x2972c
cmoveq %rax, %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdx
leaq 0x11710(%rip), %rdi     # 0x262b5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: x_hashtab
void
x_hashtab(hashtab_t *that, FILE *fpp)
{	symentry_t *list;
	int j;

	for (j = 0; j < that->tsize; j++)
	for (list = that->tab[j]; list; list = list->next)
		x_frag(list->node, fpp);
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x14c05
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rcx
movq (%rcx,%r15,8), %r12
testq %r12, %r12
je 0x14bef
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x13c1e
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0x14bd5
movl (%r14), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x14bc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: strip_pthread_fct
static void
strip_pthread_fct(char *what)
{	char *q, *r, *s, *t;

	q = t = strstr(OutBuf, what);
	if (!q) return;

	q += strlen(what);
	r = strrchr(q, ')');
	if (!r) return;

	for (s = t; s <= r; s++)
	{	*s = ' ';	// erase the fct call
	}
	*t = '0';
	// in the model no error is returned from pthread_create or pthread_join

	// sample result in OutBuf at this point: "C: (0!=(Pmain->err=0"
	// the original condition had a call to 'what()' inside this condition
	// the 'what()' call was moved outside the condition
	//
	// we replace the removed function call with 0, meaning non-failure
	// if the original condition had an embedded assignment of the result
	// we need to remove that side-effect as well (hoping that the variable
	// assigned zero does not get reused somewhere later -- this is a hack

	// look if there was an assignment operator directly before 'what()'
	fix_side_effect(t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x24530(%rip), %r14     # 0x39380
movq %r14, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
je 0x14f64
movq %rax, %rbx
movq %r15, %rdi
callq 0x4110
leaq (%rax,%rbx), %rdi
movl $0x29, %esi
callq 0x4150
testq %rax, %rax
je 0x14f64
cmpq %rax, %rbx
ja 0x14eac
leaq 0x1(%rbx), %rcx
incq %rax
cmpq %rax, %rcx
cmovaq %rcx, %rax
subq %rbx, %rax
movq %rbx, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x4180
movb $0x30, (%rbx)
decq %rbx
movb (%rbx), %al
cmpb $0x20, %al
jne 0x14ec2
cmpq %r14, %rbx
ja 0x14eaf
jmp 0x14f64
cmpb $0x9, %al
jne 0x14ecb
cmpq %r14, %rbx
ja 0x14eaf
cmpq %r14, %rbx
setbe %cl
cmpb $0x3d, %al
setne %al
orb %cl, %al
jne 0x14f64
callq 0x42e0
movq (%rax), %rax
movsbq -0x1(%rbx), %rcx
testb $0x8, (%rax,%rcx,2)
je 0x14f64
leaq 0x24488(%rip), %rbx     # 0x39380
movq %rbx, %rdi
callq 0x4110
testq %rax, %rax
je 0x14f4c
xorl %ecx, %ecx
xorl %ebp, %ebp
movzbl (%rcx,%rbx), %edx
cmpl $0x29, %edx
je 0x14f1b
cmpl $0x28, %edx
jne 0x14f1d
incl %ebp
jmp 0x14f1d
decl %ebp
incq %rcx
cmpq %rcx, %rax
jne 0x14f09
movl $0x203a43, 0x24451(%rip) # imm = 0x203A43
testl %ebp, %ebp
jle 0x14f56
incl %ebp
movq %rbx, %rdi
callq 0x4110
movw $0x28, (%rax,%rbx)
decl %ebp
cmpl $0x1, %ebp
ja 0x14f35
jmp 0x14f56
movl $0x203a43, 0x2442a(%rip) # imm = 0x203A43
movq %rbx, %rdi
callq 0x4110
movw $0x30, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: replace_pthread_join
static void
replace_pthread_join(void)
{	char *q, *r;

	q = strstr(OutBuf, "pthread_join(");
	if (!q) return;

	r = q + strlen("pthread_join(");
	// keep the arguments
	// and make this a blocking statement
	fprintf(fp, "	c_expr { spin_join(%s }\n", r);

	strip_pthread_fct("pthread_join(");
}

// Assembly:
pushq %rax
leaq 0x24409(%rip), %rdi     # 0x39380
leaq 0x10784(%rip), %rsi     # 0x25702
callq 0x42d0
testq %rax, %rax
je 0x14fb1
addq $0xd, %rax
movq 0x243dd(%rip), %rdi     # 0x39370
leaq 0x10d86(%rip), %rsi     # 0x25d20
movq %rax, %rdx
xorl %eax, %eax
callq 0x41d0
leaq 0x10757(%rip), %rdi     # 0x25702
popq %rax
jmp 0x14e3f
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: fct_params
static void
fct_params(treenode *fct, treenode *pars)
{
	if (!fct || !pars || !visu) return;

	switch (pars->hdr.which) {
	case NODE_T:
		switch (pars->hdr.type) {
		case TN_PARAM_LIST:
		case TN_EXPR_LIST:
			fct_params(fct, pars->lnode);
			if (pars->rnode)
			{	fct_params(fct, pars->rnode);
			}
			break;
		default:
			goto A;
		}
		break;
	default:
A:		fprintf(fp, "\t\tc_code { now.par%d_", par_cnt++);
		print_tree(fct, fp);
		fprintf(fp, " = ");
#if 1
		strcpy(AltBuf, OutBuf);
		strcpy(OutBuf, "");
		modex_recur(pars);
		fprintf(fp, "%s", OutBuf);	// fct_params()
		strcpy(OutBuf, AltBuf);
		strcpy(AltBuf, "-x-x-");
#else
		if (((leafnode *) pars)->hdr.type == TN_IDENT)
		{	strcpy(AltBuf, OutBuf);
			strcpy(OutBuf, "");
			do_prefix((leafnode *)pars);
			fprintf(fp, OutBuf);	// fct_params()
			strcpy(OutBuf, AltBuf);
			strcpy(AltBuf, "-x-x-");
		}
		print_recur(pars, fp);
#endif
		fprintf(fp, "; };\n");
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15581
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x23487(%rip), %r15     # 0x389d8
testq %rbx, %rbx
je 0x15581
cmpl $0x0, (%r15)
je 0x15581
cmpl $0x4, (%rbx)
jne 0x15587
movl 0x1c(%rbx), %eax
orl $0x4, %eax
cmpl $0xe, %eax
jne 0x15587
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x1553a
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x15551
popq %rbx
popq %r14
popq %r15
retq
movq 0x23de2(%rip), %rdi     # 0x39370
movl 0x32864(%rip), %edx     # 0x47df8
leal 0x1(%rdx), %eax
movl %eax, 0x3285b(%rip)     # 0x47df8
leaq 0x109d8(%rip), %rsi     # 0x25f7c
xorl %eax, %eax
callq 0x41d0
movq 0x23dbe(%rip), %rsi     # 0x39370
movq %r14, %rdi
callq 0x209ca
movq 0x23daf(%rip), %rcx     # 0x39370
leaq 0x17da1(%rip), %rdi     # 0x2d369
movl $0x3, %esi
movl $0x1, %edx
callq 0x42c0
leaq 0x2a512(%rip), %r14     # 0x3faf0
leaq 0x23d9b(%rip), %r15     # 0x39380
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b0
movb $0x0, 0x23d89(%rip)     # 0x39380
movq %rbx, %rdi
callq 0xaca3
movq 0x23d6a(%rip), %rsi     # 0x39370
movq %r15, %rdi
callq 0x4170
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b0
movl $0x782d782d, 0x2a4cd(%rip) # imm = 0x782D782D
movw $0x2d, 0x2a4c8(%rip)    # 0x3faf4
movq 0x23d3d(%rip), %rcx     # 0x39370
leaq 0x106a1(%rip), %rdi     # 0x25cdb
movl $0x5, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/xtract.c
// Function: map_neg
static char *
map_neg(treenode *n, char *oO)
{	char *p;

	vis_start();
	vis_print("C: !");
	vis_print(oO);

	owf = wasfalse;
	owt = wastrue;
	owe = waselse;
	owh = ishidden;
	if (!strstr(oO, ND_CHOICE))
		PosElse = 1;
	p = vis_lookup(n);		/* map */
	PosElse = 0;
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x2394b(%rip)     # 0x39380
leaq 0xf25a(%rip), %rdi      # 0x24c96
callq 0x12500
movq %r14, %rdi
callq 0x12500
movl 0x2c0a5(%rip), %eax     # 0x41af4
movl %eax, 0x2f75f(%rip)     # 0x451b4
movl 0x2c09d(%rip), %eax     # 0x41af8
movl %eax, 0x323a7(%rip)     # 0x47e08
movl 0x2c089(%rip), %eax     # 0x41af0
movl %eax, 0x2f743(%rip)     # 0x451b0
leaq 0xffc6(%rip), %rsi      # 0x25a3a
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
jne 0x15a88
movb $0x1, 0x2a058(%rip)     # 0x3fae0
movq %rbx, %rdi
callq 0x119ed
movb $0x0, 0x2a049(%rip)     # 0x3fae0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/tree.c
// Function: find_func_name
leafnode *
find_func_name(treenode *n)
{
	while (n && (n->hdr.which != LEAF_T))
	{	switch(n->hdr.which) {
		case NODE_T:
			switch(n->hdr.type) {
			case TN_DECL:
				n = n->rnode;
				break;
			case TN_FUNC_DECL:
				n = n->lnode;
				break;
			default:
				goto bad;
			}
			break;
		case FOR_T:
			if (n->hdr.type == TN_FUNC_DEF)
				n = ((for_node *) n)->test;
			break;
		default:
bad:			fprintf(stderr,
				"%s: error: bad node in find_func_name;\n"
				"	node: %s, type: %s\n",
				progname, name_of_nodetype(n->hdr.which),
				name_of_node(n->hdr.type));
			n = NULL;
			break;
	}	}

	return (leafnode*) n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16670
movq %rdi, %rbx
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x16655
cmpl $0x4, %eax
jne 0x16674
movl 0x1c(%rbx), %ecx
cmpl $0x2, %ecx
je 0x16662
movl $0x38, %eax
cmpl $0x5, %ecx
je 0x16667
jmp 0x166ae
movl $0x38, %eax
cmpl $0x1, 0x1c(%rbx)
je 0x16667
jmp 0x1666b
movl $0x30, %eax
movq (%rbx,%rax), %rbx
testq %rbx, %rbx
jne 0x16635
xorl %ebx, %ebx
jmp 0x16679
cmpl $0x1, %eax
jne 0x16688
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1f969(%rip), %rcx     # 0x35ff8
movq (%rcx), %r14
leaq 0x1fb07(%rip), %rcx     # 0x361a0
movq (%rcx), %r15
testl %eax, %eax
je 0x166cb
cmpl $0x2, %eax
jne 0x166d4
leaq 0x1080d(%rip), %r12     # 0x26eb9
jmp 0x166db
movq 0x1f943(%rip), %rax     # 0x35ff8
movq (%rax), %r14
leaq 0x1fae1(%rip), %rax     # 0x361a0
movq (%rax), %r15
leaq 0x107fb(%rip), %r12     # 0x26ec4
jmp 0x166db
leaq 0x107d9(%rip), %r12     # 0x26eab
jmp 0x166db
leaq 0x107f0(%rip), %r12     # 0x26ecb
movl 0x1c(%rbx), %edi
callq 0x16550
leaq 0x1046d(%rip), %rsi     # 0x26b57
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x41d0
jmp 0x16679
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/tree.c
// Function: find_components
void
find_components(treenode *decl, treenode *def,
                      treenode *container, FindFunction find)
{
    if (!decl)
        return;

    switch(decl->hdr.which)
    {
        case NODE_T:
        {
            switch(decl->hdr.type)
            {
            case TN_COMP_DECL:
            case TN_DECL:
                find_ident_name(decl,decl,container,find);
                break;

            case TN_DECL_LIST:
            case TN_DECLS:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FIELD_LIST:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FUNC_DECL:
                find_components(decl->rnode,def,container,find);
                break;

            default:
                fprintf(stderr,
                    "%s: parse error: "
                    "unknown node type (%s) in find_components\n",
                    progname, name_of_node(decl->hdr.type));
                break;
            }
        }
    break;

    case LEAF_T:
    case IF_T:
    case FOR_T:
    case NONE_T:
    default:
        fprintf(stderr,
         "%s: parse error: unknown node %s in find_components;\n"
         "  type is: %s\n", progname, print_ptr(decl), name_of_nodetype(decl->hdr.which));
        break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x16813
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10037(%rip), %r13     # 0x2680c
cmpl $0x4, (%r15)
jne 0x1683c
movl 0x1c(%r15), %edi
leal -0x8(%rdi), %eax
cmpl $0x9, %eax
ja 0x16805
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x30(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x167b4
jmp 0x1680a
cmpl $0x2, %edi
jne 0x1681d
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x167d5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpl $0x5, %edi
jne 0x16846
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1656e
movq %r15, %rdi
callq 0x54e1
jmp 0x16813
callq 0x5552
jmp 0x16813
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: new_stk_item
Stk_Item  *
new_stk_item( FILE *fp, char *fname )
{
    Stk_Item *stk_item;

	if (freestk)
	{	stk_item = freestk;
		freestk = freestk->next;
		memset(stk_item, 0, STK_ITEM_SZE);
	} else
		stk_item = e_malloc(STK_ITEM_SZE);

    stk_item->filename = e_malloc(strlen(fname)+1);
    strcpy(stk_item->filename, fname);

    if ((stk_item->yybuff = yy_create_buffer(fp, YYBUFF_SIZE )) == NULL){
        e_free(stk_item->filename);
        e_free(stk_item);
        return((Stk_Item *) NULL);
    }

    if ((stk_item->node_heap  = CreateHeap(MX_NODE_SZE, 0)) == NULL){
        e_free(stk_item->filename);
        yy_delete_buffer( stk_item->yybuff );
        e_free(stk_item);
        return((Stk_Item *) NULL);
    }

    stk_item->yyin     = fp;

    stk_item->yylineno = 1;
    stk_item->yycolno  = 0;
    stk_item->yynxtcol = 0;

    stk_item->parse_tree = (treenode *) NULL;

    stk_item->next = (Stk_Item *) NULL;

    return(stk_item);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x315de(%rip), %rbx     # 0x47e40
testq %rbx, %rbx
je 0x16886
movq 0x38(%rbx), %rax
movq %rax, 0x315ce(%rip)     # 0x47e40
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x16893
movl $0x40, %edi
callq 0x6321
movq %rax, %rbx
movq %r15, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1bf73
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x168fb
movl $0x50, %edi
xorl %esi, %esi
callq 0x5f4c
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x16906
movq %r14, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x38(%rbx)
jmp 0x16922
movq 0x10(%rbx), %rdi
callq 0x6320
jmp 0x16918
movq 0x10(%rbx), %rdi
callq 0x6320
movq 0x30(%rbx), %rdi
callq 0x1c392
movq %rbx, %rdi
callq 0x6320
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: push
void
push(TreeStack *treestk, Stk_Item *stk_item )
{
    if (! treestk || ! stk_item)
        return;

    stk_item->next = treestk->top;

    if (! treestk->top)
        treestk->bottom = stk_item;

    treestk->top = stk_item;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x169aa
movq (%rdi), %rax
movq %rax, 0x38(%rsi)
testq %rax, %rax
jne 0x169a7
movq %rsi, 0x8(%rdi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: top_file
FILE *
top_file(TreeStack *treestk)
{
    if (is_empty(treestk))
        return((FILE *) NULL);
    else
        return(treestk->top->yyin);
}

// Assembly:
testq %rdi, %rdi
je 0x16a03
movq (%rdi), %rax
testq %rax, %rax
je 0x16a03
movq 0x18(%rax), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: reset_position
void
reset_position(TreeStack *treestk)
{
    if ( !(Parse_TOS = top_of_stack(treestk)))
        return;

    yy_switch_to_buffer(Parse_TOS->yybuff);
    yyin = top_file(treestk);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x16a38
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x21fef(%rip), %rcx     # 0x38a08
movq %rax, (%rcx)
testq %rax, %rax
je 0x16a54
movq 0x30(%rax), %rdi
callq 0x1c2fa
movq (%rbx), %rax
testq %rax, %rax
je 0x16a48
movq 0x18(%rax), %rax
jmp 0x16a4a
leaq 0x21fc9(%rip), %rax     # 0x38a08
movq $0x0, (%rax)
jmp 0x16a54
xorl %eax, %eax
leaq 0x313ff(%rip), %rcx     # 0x47e50
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: tree_parse
int
tree_parse(TreeStack *treestk, int parse_all)
{
    int cnt = 0;

    if (is_empty(treestk))
        return(0);

    do {
#if 0
        while(yyparse())
            ;
#else
	yyparse();	/* returns 1 on error 0 on accept */
#endif
        cnt++;
        get_next_file(treestk);

        if (is_empty(treestk))
            break;

    } while (parse_all);

    return(cnt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x16a87
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x16a87
movl %esi, %ebp
xorl %ebx, %ebx
callq 0x1c778
incl %ebx
movq %r14, %rdi
callq 0x16a8e
testl %ebp, %ebp
je 0x16a87
cmpq $0x0, (%r14)
jne 0x16a6e
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: get_next_file
int
get_next_file(TreeStack *treestk)
{
    if (is_empty(treestk)){
        Parse_TOS = (Stk_Item *) NULL;
        return(0);
    }

    if (DoneStack)
        push(DoneStack, pop(treestk));
    else {
        fputs("DoneStack was NULL.\n", stdout);
        delete_stk_item(pop(treestk));
    }

    reset_position(treestk);

    if (is_empty(treestk))
        return(0);

    return(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16ada
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x16ada
leaq 0x21f67(%rip), %rcx     # 0x38a10
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x16aec
movq 0x38(%rax), %rdx
testq %rdx, %rdx
jne 0x16ac2
movq $0x0, 0x8(%rbx)
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
testq %rdx, %rdx
jne 0x16ad5
movq %rax, 0x8(%rcx)
movq %rax, (%rcx)
jmp 0x16b57
leaq 0x21f27(%rip), %rax     # 0x38a08
movq $0x0, (%rax)
xorl %eax, %eax
jmp 0x16b68
movq 0x1f4dd(%rip), %rax     # 0x35fd0
movq (%rax), %rsi
leaq 0x103e2(%rip), %rdi     # 0x26edf
callq 0x4170
movq (%rbx), %r14
testq %r14, %r14
je 0x16b57
movq 0x38(%r14), %rax
testq %rax, %rax
jne 0x16b1b
movq $0x0, 0x8(%rbx)
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x16b45
callq 0x604a
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $0x0, 0x30(%r14)
movq 0x312f4(%rip), %rax     # 0x47e40
movq %rax, 0x38(%r14)
movq %r14, 0x312e9(%rip)     # 0x47e40
movq %rbx, %rdi
callq 0x16a06
xorl %eax, %eax
cmpq $0x0, (%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/treestk.c
// Function: handle_new_file
void
handle_new_file(TreeStack *treestk, FILE *fp, char *fname)
{
    Stk_Item *stk_item;

    if ((stk_item = new_stk_item(fp, fname)) == NULL)
        return;

    push(treestk, stk_item);
    reset_position(treestk);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x16850
testq %rax, %rax
je 0x16ba5
testq %rbx, %rbx
je 0x16b9c
movq (%rbx), %rcx
movq %rcx, 0x38(%rax)
testq %rcx, %rcx
jne 0x16b99
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x16a06
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: doit
char *
doit(leafnode *leaf, int how)
{	scopetab_t *z;
	static char bstr[1024];
	static char lstr[1024];

	if (!leaf) return (char *) 0;

	if (leaf->syment && leaf->syment->nes)
		z = leaf->syment->nes;
	else
		z = (scopetab_t *) 0;

	strcpy(lstr, "");
	switch (how) {
	case 2:	sprintf(bstr, "%d:", leaf->hdr.line);
		strcat(lstr, bstr);	/* fall thru */
	case 0:	sprintf(bstr, "%s::", z?z->owner:"-");
		strcat(lstr, bstr);	/* fall thru */
	case 1:	sprintf(bstr, "%s%s", nmestr(leaf->data.sval), (!how)?" ":"");
		strcat(lstr, bstr);
	}
	return &lstr[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1de87
movl %esi, %ebx
movq %rdi, %r14
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1de34
movq 0x18(%rax), %r12
testq %r12, %r12
jne 0x1de37
xorl %r12d, %r12d
movb $0x0, 0x2e4b2(%rip)     # 0x4c2f0
testl %ebx, %ebx
je 0x1de7b
cmpl $0x1, %ebx
je 0x1decc
cmpl $0x2, %ebx
jne 0x1de8b
movl 0x10(%r14), %edx
leaq 0x2e095(%rip), %r15     # 0x4bef0
leaq 0x832b(%rip), %rsi      # 0x2618d
movq %r15, %rdi
xorl %eax, %eax
callq 0x42a0
leaq 0x2e47d(%rip), %rdi     # 0x4c2f0
movq %r15, %rsi
callq 0x4290
testq %r12, %r12
je 0x1de9e
movq 0x18(%r12), %rdx
jmp 0x1dea5
xorl %eax, %eax
jmp 0x1de92
leaq 0x2e45e(%rip), %rax     # 0x4c2f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5bf6(%rip), %rdx      # 0x23a9b
leaq 0x2e044(%rip), %r15     # 0x4bef0
leaq 0xf5fd(%rip), %rsi      # 0x2d4b0
movq %r15, %rdi
xorl %eax, %eax
callq 0x42a0
leaq 0x2e42c(%rip), %rdi     # 0x4c2f0
movq %r15, %rsi
callq 0x4290
movq 0x30(%r14), %rdi
callq 0x61c4
testl %ebx, %ebx
leaq 0x6e7a(%rip), %rdx      # 0x24d58
leaq 0x81ac(%rip), %rcx      # 0x26091
cmoveq %rdx, %rcx
leaq 0x2e000(%rip), %rbx     # 0x4bef0
leaq 0xf5be(%rip), %rsi      # 0x2d4b5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x42a0
leaq 0x2e3e5(%rip), %rdi     # 0x4c2f0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4290
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_node
DuG *
dep_node(SymList *a, int imark)
{	DuG *g;

	for (g = du_g; g; g = g->nxt)
		if (g->sm == a->sm)
		{	g->marks |= imark;
			goto done;
		}

	g = (DuG *) e_malloc(sizeof(DuG));

	if (!a->sm) printf("%s: dep_node without symbol\n", progname);

	g->sm = a->sm;
	g->marks = imark;
	g->rdcls |= RealDecls;
	g->d_e = (DuGP *) 0;
	g->nxt = du_g;
	du_g = g;
done:
	return g;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x2e7c2(%rip), %rbx     # 0x4c6f0
testq %rbx, %rbx
je 0x1df45
movq 0x8(%r14), %rax
cmpq %rax, (%rbx)
je 0x1dfa2
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1df37
movl $0x20, %edi
callq 0x6321
movq %rax, %rbx
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0x1df77
leaq 0x1823e(%rip), %rax     # 0x361a0
movq (%rax), %rsi
leaq 0xf54e(%rip), %rdi      # 0x2d4ba
xorl %eax, %eax
callq 0x4140
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
movl 0x2e775(%rip), %eax     # 0x4c6f8
orl %eax, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x2e75b(%rip), %rax     # 0x4c6f0
movq %rax, 0x18(%rbx)
movq %rbx, 0x2e750(%rip)     # 0x4c6f0
jmp 0x1dfa5
orl %ebp, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_edge
int
dep_edge(DuG *a, DuG *b, int dist)
{	DuGP *e;

	if (a->sm == b->sm)
		return 0;		/* self-loop */

	for (e = a->d_e; e; e = e->nxt)
	{	if (e->ptr == b)
			return 0;	/* already there */
	}

	e = (DuGP *) e_malloc(sizeof(DuGP));
	e->ptr = b;
	e->dist = dist;
	e->nxt = a->d_e;
	a->d_e = e;

	return 1;
}

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
cmpq (%rsi), %rcx
je 0x1dffc
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1dfd7
cmpq %r14, (%rcx)
je 0x1dff8
movq 0x10(%rcx), %rcx
jmp 0x1dfc7
movl $0x18, %edi
callq 0x6321
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_trans
void
dep_trans(void)	/* transitive closure */
{	DuG *g, *t;
	DuGP *s, *u;
	int dist, cnt;

	do {	cnt = 0;
		for (g = du_g; g; g = g->nxt)
		for (s = g->d_e; s; s = s->nxt)			/* successors */
		{	t = s->ptr;				/* one successor in DuG */
			for (u = t->d_e; u; u = u->nxt)		/* the successors of this */
			{	dist = s->dist + u->dist;
				if (dep_edge(g, u->ptr, dist))
					cnt++;
			}
		}
	} while (cnt > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2e6e5(%rip), %rbx     # 0x4c6f0
testq %rbx, %rbx
je 0x1e066
xorl %ebp, %ebp
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1e048
movq (%r14), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x1e042
movl 0x8(%r15), %edx
addl 0x8(%r14), %edx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x1dfad
addl %eax, %ebp
movq 0x10(%r15), %r15
jmp 0x1e022
movq 0x10(%r14), %r14
jmp 0x1e016
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e012
testl %ebp, %ebp
jle 0x1e066
movq 0x2e694(%rip), %rbx     # 0x4c6f0
movl $0x0, %ebp
testq %rbx, %rbx
jne 0x1e012
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_warn
void
dep_warn(int m)
{
	if (!(m&DEF) || !(m&USE))
	{
		if (!(m&DEF))
			fprintf(stdout, "\t%snever defined",
				(m&USE)?"used but ":"never used and ");
		else if (!(m&USE))
			fprintf(stdout, "\tdefined but never used");
	}
	fprintf(stdout, "%s\n", (m&HIDE)?" hidden":"");
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, %eax
notl %eax
testb $0x5, %al
je 0x1e0d5
testb $0x1, %bl
jne 0x1e0b0
testb $0x4, %bl
movq 0x17f45(%rip), %rax     # 0x35fd0
movq (%rax), %rdi
leaq 0xf45d(%rip), %rax      # 0x2d4f2
leaq 0xf44c(%rip), %rdx      # 0x2d4e8
cmoveq %rax, %rdx
leaq 0xf430(%rip), %rsi      # 0x2d4d7
xorl %eax, %eax
callq 0x41d0
jmp 0x1e0d5
testb $0x4, %bl
jne 0x1e0d5
movq 0x17f14(%rip), %rax     # 0x35fd0
movq (%rax), %rcx
leaq 0xf43c(%rip), %rdi      # 0x2d502
movl $0x17, %esi
movl $0x1, %edx
callq 0x42c0
movq 0x17ef4(%rip), %rax     # 0x35fd0
movq (%rax), %rdi
btl $0x9, %ebx
leaq 0x7fa7(%rip), %rax      # 0x26091
leaq 0xf429(%rip), %rdx      # 0x2d51a
cmovaeq %rax, %rdx
leaq 0x6280(%rip), %rsi      # 0x2437c
xorl %eax, %eax
popq %rbx
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_show
void
dep_show(void)
{	DuG  *g;
	DuGP *s;

	dep_trans();
	fprintf(stdout, "\n");

	for (g = du_g; g; g = g->nxt)
	{	if (!g->d_e
		||  !g->rdcls)
			continue;

		fprintf(stdout, "%s:\n", g->sm->nme->str);
		for (s = g->d_e; s; s = s->nxt)
			fprintf(stdout, "\t-%s-> %s\n",
				(s->dist>1)?"*":"",
				s->ptr->sm->nme->str);
	}
	fprintf(stdout, "\n");

	for (g = du_g; g; g = g->nxt)
	{	if (!g->marks
		||  !g->rdcls
		|| (!(Verbose&2) && (g->marks&HIDE)))
			continue;

		if (!(g->marks&DEF)
		||  !(g->marks&USE))
		{

			if (g->sm
			&&  find_symbol(g->sm->nes, g->sm))
			{	fprintf(stdout, " %s", g->sm->nme->str);
				dep_warn(g->marks);
			}	/* else it's not a reportable item */
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1dffd
movq 0x17eb5(%rip), %r15     # 0x35fd0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4190
movq 0x2e5c1(%rip), %r12     # 0x4c6f0
testq %r12, %r12
je 0x1e1ba
leaq 0x7304(%rip), %r13      # 0x25443
leaq 0x7f4b(%rip), %rbp      # 0x26091
leaq 0xf3d5(%rip), %r14      # 0x2d522
cmpq $0x0, 0x10(%r12)
je 0x1e1b0
cmpl $0x0, 0xc(%r12)
je 0x1e1b0
movq (%r15), %rdi
movq (%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x801e(%rip), %rsi      # 0x26191
xorl %eax, %eax
callq 0x41d0
movq 0x10(%r12), %rbx
testq %rbx, %rbx
je 0x1e1b0
cmpl $0x2, 0x8(%rbx)
movq (%r15), %rdi
movq %rbp, %rdx
cmovgeq %r13, %rdx
movq (%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x41d0
movq 0x10(%rbx), %rbx
jmp 0x1e17f
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1e14d
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4190
movq 0x2e522(%rip), %r14     # 0x4c6f0
testq %r14, %r14
je 0x1e247
leaq 0x1a8a2(%rip), %r12     # 0x38a7c
leaq 0x6f65(%rip), %rbx      # 0x25146
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x1e23e
cmpl $0x0, 0xc(%r14)
je 0x1e23e
testb $0x2, (%r12)
sete %cl
movl %eax, %edx
notl %edx
testb $0x5, %dl
je 0x1e23e
shrl $0x9, %eax
andb %cl, %al
jne 0x1e23e
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1e23e
movq 0x18(%rsi), %rdi
callq 0x69f5
testl %eax, %eax
je 0x1e23e
movq (%r15), %rdi
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x41d0
movl 0x8(%r14), %edi
callq 0x1e071
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x1e1e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dep_graph
void
dep_graph(DefUse *d)
{	SymList *s, *t;
	DuG *a, *b;

	if (!d || preview) return;

	if (!d->def)
	for (t = d->use; t; t = t->nxt)
		dep_node(t, USE);

	for (s = d->def; s; s = s->nxt)
	{	a = dep_node(s, DEF);
		for (t = d->use; t; t = t->nxt)
		{	b = dep_node(t, USE);
			if (s->sm != t->sm)
				dep_edge(a, b, 1);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x1e307
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1a7ce(%rip), %rax     # 0x38a3c
cmpl $0x0, (%rax)
jne 0x1e2fc
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
jne 0x1e2ab
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1e2fc
movq %r14, %rdi
movl $0x4, %esi
callq 0x1df1e
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1e28c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1e2fc
movq %r14, %rdi
movl $0x1, %esi
callq 0x1df1e
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x1e2f6
movq %rax, %r15
movq %r12, %rdi
movl $0x4, %esi
callq 0x1df1e
movq 0x8(%r14), %rcx
cmpq 0x8(%r12), %rcx
je 0x1e2ec
movq %r15, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x1dfad
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x1e2c4
movq 0x10(%r14), %r14
jmp 0x1e2a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: mark_defs
void
mark_defs(DefUse *d, int how, FILE *fp)	/* how=0: keep or map, HIDE: comment, print or hide */
{	SymList *s;
	DuG *g;

	for (s = d->def; s; s = s->nxt)
	for (g = du_g; g; g = g->nxt)
		if (g->sm == s->sm)
		{
			if ((g->marks & (DEF|(how&~HIDE))) != (DEF|(how&~HIDE)))
				fprintf(fp, "markdefs:%s: %d <-> %d | %d\n",
					g->sm->nme->str, g->marks, DEF, (how&~HIDE));
			g->marks |= (DEF|how);
		}

	for (s = d->use; s; s = s->nxt)
	for (g = du_g; g; g = g->nxt)
		if (g->sm == s->sm)
		{
			if ((g->marks & USE) != USE)
				fprintf(fp, "markdefs:%s: %d <-> %d\n",
					g->sm->nme->str, g->marks, USE);
			g->marks |= USE;	/* no hide's here */
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, (%rsp)
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0x1e39b
movl %esi, %ebp
movl %esi, %r14d
andl $0xfffffdff, %r14d      # imm = 0xFFFFFDFF
movl %r14d, %r15d
orl $0x1, %r15d
movq 0x2e3b3(%rip), %r12     # 0x4c6f0
testq %r12, %r12
je 0x1e392
movq (%r12), %rax
cmpq 0x8(%r13), %rax
jne 0x1e38b
movl 0x8(%r12), %ecx
movl %ecx, %edx
notl %edx
testl %edx, %r15d
je 0x1e381
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
leaq 0xf1c1(%rip), %rsi      # 0x2d52d
movl $0x1, %r8d
movl %r14d, %r9d
xorl %eax, %eax
callq 0x41d0
movl 0x8(%r12), %ecx
orl %ebp, %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%r12)
movq 0x18(%r12), %r12
jmp 0x1e33d
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1e336
movq (%rsp), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x1e407
leaq 0xf19b(%rip), %r14      # 0x2d54a
movq 0x2e33a(%rip), %r12     # 0x4c6f0
testq %r12, %r12
je 0x1e3fe
movq (%r12), %rax
cmpq 0x8(%r15), %rax
jne 0x1e3f7
movl 0x8(%r12), %ecx
testb $0x4, %cl
jne 0x1e3ef
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %r8d
xorl %eax, %eax
callq 0x41d0
movl 0x8(%r12), %ecx
orl $0x4, %ecx
movl %ecx, 0x8(%r12)
movq 0x18(%r12), %r12
jmp 0x1e3b6
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1e3af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: attach_defuse
void
attach_defuse(treenode *n, char *t, DefUse *d)
{
	if (!d || !n) return;

	if (d->def || d->use)
		dep_graph(d);	/* update the graph */

	if (n->hdr.defuse)
	{	if (n->hdr.defuse != d
		&&  !same_defuse(d, n->hdr.defuse))
		{	printf("%s: %s:%d attach_defuse conflict %s %s\n",
				progname, n->hdr.fnm, n->hdr.line,
#ifdef DEFTYP
				n->hdr.deftyp,
#else
				"",
#endif
				t);
			printf("OLD:\n");
			dump_defuse(n->hdr.defuse, stdout);
			printf("\nNEW:\n");
			dump_defuse(d, stdout);
			printf("\n");
		}
	} else
	{	n->hdr.defuse = d;
#ifdef DEFTYP
		n->hdr.deftyp = t;
#endif
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x1e79b
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdx)
jne 0x1e70a
cmpq $0x0, 0x10(%rbx)
je 0x1e712
movq %rbx, %rdi
callq 0x1e256
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x1e797
cmpq %rbx, %rax
je 0x1e79b
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
setne %dil
testq %rcx, %rcx
setne %sil
movl %edi, %r8d
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x1e769
movq 0x8(%rdx), %rsi
cmpq 0x8(%rcx), %rsi
jne 0x1e7a6
movq 0x10(%rcx), %rcx
movq 0x10(%rdx), %rdx
testq %rcx, %rcx
setne %sil
testq %rdx, %rdx
setne %dil
je 0x1e769
testq %rcx, %rcx
jne 0x1e742
testb %dil, %dil
jne 0x1e7a6
testb %sil, %sil
jne 0x1e7a6
movq %rbx, %rcx
movq %rax, %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x1e7a1
testq %rdx, %rdx
je 0x1e7a1
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
je 0x1e779
jmp 0x1e7a6
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
orq %rdx, %rcx
je 0x1e815
leaq 0x179f3(%rip), %rax     # 0x361a0
movq (%rax), %rsi
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
leaq 0xedbc(%rip), %rdi      # 0x2d57b
leaq 0x78cb(%rip), %r8       # 0x26091
movq %r15, %r9
xorl %eax, %eax
callq 0x4140
leaq 0xef48(%rip), %rdi      # 0x2d71f
callq 0x40d0
movq 0x20(%r14), %rdi
movq 0x177e9(%rip), %r14     # 0x35fd0
movq (%r14), %rsi
callq 0x1e416
leaq 0xef2e(%rip), %rdi      # 0x2d724
callq 0x40d0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1e416
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x4050
movq 0x18(%rax), %rax
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
setne %sil
testq %rax, %rax
setne %dl
movl %esi, %edi
andb %dl, %dil
cmpb $0x1, %dil
jne 0x1e86b
movq 0x8(%rcx), %rdx
cmpq 0x8(%rax), %rdx
jne 0x1e7a6
movl 0x4(%rcx), %edx
cmpl 0x4(%rax), %edx
jne 0x1e7a6
movq 0x10(%rax), %rax
movq 0x10(%rcx), %rcx
testq %rax, %rax
setne %dl
testq %rcx, %rcx
setne %sil
je 0x1e86b
testq %rax, %rax
jne 0x1e835
testb %sil, %sil
jne 0x1e7a6
testb %dl, %dl
je 0x1e79b
jmp 0x1e7a6
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: set_fbase
void
set_fbase(int ln, char *s)
{	Fbase *f;

	if (!show_funcs) fbase = (Fbase *) 0;

	f = (Fbase *) e_malloc(sizeof(Fbase));
	f->nm = (char *) e_malloc(strlen(s)+1);
	strcpy(f->nm, s);
	f->ln = ln;
	f->fcalls = (Fbase *) 0;
	f->nxt = fbase;
	fbase = f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x1a1a6(%rip), %rax     # 0x38a74
cmpl $0x0, (%rax)
jne 0x1e8de
movq $0x0, 0x2de2a(%rip) # 0x4c708
movl $0x20, %edi
callq 0x6321
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6321
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movl %ebx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq 0x2ddec(%rip), %rax     # 0x4c708
movq %rax, 0x18(%r15)
movq %r15, 0x2dde1(%rip)     # 0x4c708
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: act_fcall
void
act_fcall(FILE *fd, Fbase *f)
{
	if (!f) return;
	act_fcall(fd, f->fcalls);

	if (!f->fcalls
	||  strcmp(f->fcalls->nm, f->nm) != 0)
		fprintf(fd, "\n	%s\t", f->nm);
	fprintf(fd, "%d ", f->ln);
}

// Assembly:
testq %rsi, %rsi
je 0x1e98f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1e92d
movq (%r14), %r15
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1e961
movq (%rax), %rdi
movq %r15, %rsi
callq 0x41c0
testl %eax, %eax
je 0x1e975
leaq 0xec3b(%rip), %rsi      # 0x2d5a3
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x41d0
movl 0x8(%r14), %edx
leaq 0x4f04(%rip), %rsi      # 0x23884
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x41d0
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: act_fbase
void
act_fbase(FILE *fd, Fbase *f)
{
	if (!f) return;
	act_fbase(fd, f->nxt);

/*	fprintf(fd, "%s	%d", f->nm, f->ln);	*/
	act_fcall(fd, f->fcalls);	/* reverse order */
	fprintf(fd, "\n");
}

// Assembly:
testq %rsi, %rsi
je 0x1e9c8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0x1e990
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x1e92d
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4190
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: bugger
void
bugger(char *store, treenode *root, int top)
{	leafnode *leaf;

	if (!root) return;

	switch (root->hdr.which) {
	case LEAF_T:
		leaf = (leafnode *) root;
		switch (leaf->hdr.type) {
		case TN_IDENT:
			strcat(store, leaf->data.sval->str);
			break;
		default:
			goto bad;
		}
		break;
	case NODE_T:
		switch (root->hdr.type) {
		case TN_SELECT:
			bugger(store, root->lnode, 0);
			if (root->hdr.tok == ARROW)
				strcat(store, "->");
			else
				strcat(store, ".");
			bugger(store, root->rnode, 0);
			break;
		case TN_FUNC_CALL:
			bugger(store, root->lnode, 0);
			strcat(store, "()");
			break;
		default:
			goto bad;
		}
		break;
	default:
bad:		strcat(store, "<unknown type>");
		break;
	}

	if (top) strcat(store, "()");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1eb62
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x4, %eax
je 0x1eae7
cmpl $0x1, %eax
jne 0x1eb26
cmpl $0x2d, 0x1c(%r14)
jne 0x1eb26
movq 0x30(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4290
jmp 0x1eb4b
movl 0x1c(%r14), %eax
cmpl $0x3, %eax
je 0x1eb6d
cmpl $0x27, %eax
jne 0x1eb26
movq 0x30(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1eaaa
movl 0x18(%r14), %r15d
movq %rbx, %rdi
callq 0x4110
addq %rbx, %rax
cmpl $0x175, %r15d           # imm = 0x175
jne 0x1eb90
movb $0x0, 0x2(%rax)
movw $0x3e2d, (%rax)         # imm = 0x3E2D
jmp 0x1eb95
movq %rbx, %rdi
callq 0x4110
movabsq $0x6e776f6e6b6e753c, %rcx # imm = 0x6E776F6E6B6E753C
movq %rcx, (%rbx,%rax)
movabsq $0x3e65707974206e, %rcx # imm = 0x3E65707974206E
movq %rcx, 0x7(%rbx,%rax)
testl %ebp, %ebp
je 0x1eb62
movq %rbx, %rdi
callq 0x4110
movw $0x2928, (%rbx,%rax)    # imm = 0x2928
movb $0x0, 0x2(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1eaaa
movq %rbx, %rdi
callq 0x4110
movw $0x2928, (%rbx,%rax)    # imm = 0x2928
movb $0x0, 0x2(%rbx,%rax)
jmp 0x1eb4b
movw $0x2e, (%rax)
movq 0x38(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1eaaa
jmp 0x1eb4b
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Modex/Src/dflow.c
// Function: dflow_mark
void
dflow_mark(FILE *fd, int mark)
{	int i;

	for (i = 1; i <= ANY; i *= 2)
		switch (mark&i) {
		case   DEF: fprintf(fd, "DEF "); break;
		case FCALL: fprintf(fd, "FCALL "); break;
		case   USE: fprintf(fd, "USE "); break;
		case  REF0: fprintf(fd, "REF0 "); break;
		case  REF1: fprintf(fd, "REF1 "); break;
		case  REF2: fprintf(fd, "REF2 "); break;
		case DEREF: fprintf(fd, "DEREF "); break;
		case ALIAS: fprintf(fd, "ALIAS "); break;
		case ARRAY_DECL: fprintf(fd, "ARRAY_DECL "); break;
		case HIDE: fprintf(fd, "HIDE "); break;
		case DECL: fprintf(fd, "DECL "); break;
		case USEafterdef: fprintf(fd, "USEafterdef "); break;
		case USEbeforedef: fprintf(fd, "USEbeforedef "); break;
		case PARAM: fprintf(fd, "PARAM "); break;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %r13d
leaq 0xe832(%rip), %r15      # 0x2d3f4
leaq 0xea30(%rip), %r12      # 0x2d5f9
leaq 0xea37(%rip), %rbp      # 0x2d607
movl %r13d, %eax
andl %ebx, %eax
cmpl $0x7f, %eax
jg 0x1ec09
cmpl $0xf, %eax
jg 0x1ec47
decl %eax
cmpl $0x7, %eax
ja 0x1ed83
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x4, %esi
movl $0x1, %edx
leaq 0xe9a5(%rip), %rdi      # 0x2d5a9
jmp 0x1ed7b
cmpl $0x3ff, %eax            # imm = 0x3FF
jle 0x1ec78
cmpl $0xfff, %eax            # imm = 0xFFF
jg 0x1ecaf
cmpl $0x400, %eax            # imm = 0x400
je 0x1ed0f
cmpl $0x800, %eax            # imm = 0x800
jne 0x1ed83
movl $0xc, %esi
movl $0x1, %edx
leaq 0xe9aa(%rip), %rdi      # 0x2d5ec
jmp 0x1ed7b
cmpl $0x10, %eax
je 0x1ed31
cmpl $0x20, %eax
je 0x1ed57
cmpl $0x40, %eax
jne 0x1ed83
movl $0x6, %esi
movl $0x1, %edx
leaq 0xe959(%rip), %rdi      # 0x2d5cc
jmp 0x1ed7b
cmpl $0x80, %eax
je 0x1ed44
cmpl $0x100, %eax            # imm = 0x100
je 0x1ed6a
cmpl $0x200, %eax            # imm = 0x200
jne 0x1ed83
movl $0x5, %esi
movl $0x1, %edx
leaq 0xe93c(%rip), %rdi      # 0x2d5e6
jmp 0x1ed7b
cmpl $0x1000, %eax           # imm = 0x1000
je 0x1ed22
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x1ed83
movl $0x6, %esi
movl $0x1, %edx
movq %rbp, %rdi
jmp 0x1ed7b
movl $0x6, %esi
movl $0x1, %edx
leaq 0xe8ca(%rip), %rdi      # 0x2d5ae
jmp 0x1ed7b
movl $0x4, %esi
movl $0x1, %edx
leaq 0xe8bb(%rip), %rdi      # 0x2d5b5
jmp 0x1ed7b
movl $0x5, %esi
movl $0x1, %edx
leaq 0xe8ad(%rip), %rdi      # 0x2d5ba
jmp 0x1ed7b
movl $0x5, %esi
movl $0x1, %edx
leaq 0xe8c0(%rip), %rdi      # 0x2d5e0
jmp 0x1ed7b
movl $0xd, %esi
movl $0x1, %edx
movq %r12, %rdi
jmp 0x1ed7b
movl $0x5, %esi
movl $0x1, %edx
leaq 0xe87e(%rip), %rdi      # 0x2d5c0
jmp 0x1ed7b
movl $0x6, %esi
movl $0x1, %edx
leaq 0xe87e(%rip), %rdi      # 0x2d5d3
jmp 0x1ed7b
movl $0x5, %esi
movl $0x1, %edx
leaq 0xe85e(%rip), %rdi      # 0x2d5c6
jmp 0x1ed7b
movl $0xb, %esi
movl $0x1, %edx
leaq 0xe85f(%rip), %rdi      # 0x2d5da
movq %r14, %rcx
callq 0x42c0
leal (,%r13,2), %eax
cmpl $0x2000, %r13d          # imm = 0x2000
movl %eax, %r13d
jb 0x1ebd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq