LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1c5d5
testb $0x1, %bl
jne 0x1c5b4
testb $0x4, %bl
movq 0x17a41(%rip), %rax     # 0x33fd0
movq (%rax), %rdi
leaq 0xee79(%rip), %rax      # 0x2b412
leaq 0xee68(%rip), %rdx      # 0x2b408
cmoveq %rax, %rdx
leaq 0xee4c(%rip), %rsi      # 0x2b3f7
xorl %eax, %eax
callq 0x41c0
jmp 0x1c5d5
testb $0x4, %bl
jne 0x1c5d5
movq 0x17a10(%rip), %rax     # 0x33fd0
movq (%rax), %rcx
leaq 0xee58(%rip), %rdi      # 0x2b422
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
movq 0x179f4(%rip), %rax     # 0x33fd0
movq (%rax), %rdi
btl $0x9, %ebx
leaq 0x79a7(%rip), %rax      # 0x23f91
leaq 0xee49(%rip), %rdx      # 0x2b43a
cmovaeq %rax, %rdx
leaq 0x5c80(%rip), %rsi      # 0x2227c
xorl %eax, %eax
popq %rbx
jmp 0x41c0
// File: /workspace/github_c_makefile_star2_O2/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 0x1c50c
movq 0x179b5(%rip), %r15     # 0x33fd0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x4180
leaq 0x2e0c3(%rip), %r12     # 0x4a6f0
leaq 0x6d0f(%rip), %r13      # 0x23343
leaq 0x7956(%rip), %rbp      # 0x23f91
leaq 0xee00(%rip), %r14      # 0x2b442
movq (%r12), %r12
testq %r12, %r12
je 0x1c6b7
cmpq $0x0, 0x10(%r12)
je 0x1c6b1
cmpl $0x0, 0xc(%r12)
je 0x1c6b1
leaq 0x10(%r12), %rbx
movq (%r15), %rdi
movq (%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x7a1b(%rip), %rsi      # 0x24091
xorl %eax, %eax
callq 0x41c0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1c6b1
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 0x41c0
addq $0x10, %rbx
jmp 0x1c67d
addq $0x18, %r12
jmp 0x1c642
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x4180
leaq 0x2e027(%rip), %r14     # 0x4a6f0
leaq 0x1a3ac(%rip), %r12     # 0x36a7c
leaq 0x696f(%rip), %rbx      # 0x23046
movq (%r14), %r14
testq %r14, %r14
je 0x1c742
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x1c73c
cmpl $0x0, 0xc(%r14)
je 0x1c73c
testb $0x2, (%r12)
sete %cl
movl %eax, %edx
notl %edx
testb $0x5, %dl
je 0x1c73c
shrl $0x9, %eax
andb %cl, %al
jne 0x1c73c
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c73c
movq 0x18(%rsi), %rdi
callq 0x4cc5
testl %eax, %eax
je 0x1c73c
movq (%r15), %rdi
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r14), %edi
callq 0x1c575
addq $0x18, %r14
jmp 0x1c6d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]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 0x1c7ec
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1a2d3(%rip), %rax     # 0x36a3c
cmpl $0x0, (%rax)
jne 0x1c7e4
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpq $0x0, 0x8(%rdi)
jne 0x1c7dc
pushq $0x4
popq %rbp
movq %rbx, %r15
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x1c7dc
movq %r15, %rdi
movl %ebp, %esi
callq 0x1c432
jmp 0x1c782
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1c432
movq %rax, %r15
movq %rbx, %r12
movq 0x10(%r12), %r12
testq %r12, %r12
je 0x1c7d8
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x1c432
movq 0x8(%r14), %rcx
cmpq 0x8(%r12), %rcx
je 0x1c7a8
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1c4bc
jmp 0x1c7a8
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
jne 0x1c797
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rdi), %r12
movl %esi, %r15d
andl $0xfffffdff, %r15d      # imm = 0xFFFFFDFF
movl %r15d, 0x4(%rsp)
orl $0x1, %r15d
movq (%r12), %r12
testq %r12, %r12
je 0x1c883
leaq 0x2dec9(%rip), %r13     # 0x4a6f0
movq (%r13), %r13
testq %r13, %r13
je 0x1c87d
movq (%r13), %rax
cmpq 0x8(%r12), %rax
jne 0x1c877
movl 0x8(%r13), %ecx
movl %ecx, %edx
notl %edx
testl %edx, %r15d
je 0x1c86e
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
leaq 0xebf3(%rip), %rsi      # 0x2b44d
pushq $0x1
popq %r8
movl 0x4(%rsp), %r9d
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r13), %ecx
orl %ebp, %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%r13)
addq $0x18, %r13
jmp 0x1c827
addq $0x10, %r12
jmp 0x1c817
leaq 0x2de66(%rip), %r12     # 0x4a6f0
leaq 0xebd9(%rip), %r15      # 0x2b46a
pushq $0x4
popq %rbp
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1c8e5
movq %r12, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1c894
movq (%r13), %rax
cmpq 0x8(%r14), %rax
jne 0x1c8df
movl 0x8(%r13), %ecx
testb $0x4, %cl
jne 0x1c8d8
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r13), %ecx
orl $0x4, %ecx
movl %ecx, 0x8(%r13)
addq $0x18, %r13
jmp 0x1c8a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]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 0x1cc01
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdx)
jne 0x1cbbb
cmpq $0x0, 0x10(%rbx)
je 0x1cbc3
movq %rbx, %rdi
callq 0x1c751
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x1cbfd
cmpq %rbx, %rax
je 0x1cc01
leaq 0x8(%rbx), %rcx
leaq 0x8(%rax), %rdx
movq (%rdx), %rdx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1cc07
testq %rdx, %rdx
je 0x1cc07
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
jne 0x1cc35
addq $0x10, %rcx
addq $0x10, %rdx
jmp 0x1cbd9
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
orq %rdx, %rcx
jne 0x1cc35
movq %rbx, %rcx
movq %rax, %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x1cc30
testq %rdx, %rdx
je 0x1cc30
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
je 0x1cc12
jmp 0x1cc35
orq %rdx, %rcx
je 0x1cca2
leaq 0x17564(%rip), %rax     # 0x341a0
movq (%rax), %rsi
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
leaq 0xe84d(%rip), %rdi      # 0x2b49b
leaq 0x733c(%rip), %r8       # 0x23f91
movq %r15, %r9
xorl %eax, %eax
callq 0x4140
leaq 0xe9d9(%rip), %rdi      # 0x2b63f
callq 0x40d0
movq 0x20(%r14), %rdi
movq 0x1735a(%rip), %r14     # 0x33fd0
movq (%r14), %rsi
callq 0x1c8f4
leaq 0xe9bf(%rip), %rdi      # 0x2b644
callq 0x40d0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1c8f4
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4050
leaq 0x18(%rbx), %rcx
addq $0x18, %rax
movq (%rax), %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1ccde
testq %rax, %rax
je 0x1ccde
movq 0x8(%rcx), %rdx
cmpq 0x8(%rax), %rdx
jne 0x1cc35
movl 0x4(%rcx), %edx
cmpl 0x4(%rax), %edx
jne 0x1cc35
addq $0x10, %rcx
addq $0x10, %rax
jmp 0x1ccaa
orq %rax, %rcx
je 0x1cc01
jmp 0x1cc35
// File: /workspace/github_c_makefile_star2_O2/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 0x19d40(%rip), %rax     # 0x36a74
cmpl $0x0, (%rax)
jne 0x1cd41
andq $0x0, 0x2d9c7(%rip)     # 0x4a708
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movl %ebx, 0x8(%r15)
andq $0x0, 0x10(%r15)
movq 0x2d98e(%rip), %rax     # 0x4a708
movq %rax, 0x18(%r15)
movq %r15, 0x2d983(%rip)     # 0x4a708
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1cded
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1cd8b
movq (%r14), %r15
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1cdbf
movq (%rax), %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
je 0x1cdd3
leaq 0xe6fd(%rip), %rsi      # 0x2b4c3
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r14), %edx
leaq 0x4aa6(%rip), %rsi      # 0x21884
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x41c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ce24
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0x1cdee
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x1cd8b
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4180
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1cfba
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x4, %eax
je 0x1cf3f
cmpl $0x1, %eax
jne 0x1cf7e
cmpl $0x2d, 0x1c(%r14)
jne 0x1cf7e
movq 0x30(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4290
jmp 0x1cfa3
movl 0x1c(%r14), %eax
cmpl $0x3, %eax
je 0x1cfc5
cmpl $0x27, %eax
jne 0x1cf7e
movq 0x30(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1cf02
movl 0x18(%r14), %r15d
movq %rbx, %rdi
callq 0x4110
addq %rbx, %rax
cmpl $0x175, %r15d           # imm = 0x175
jne 0x1cfe8
movb $0x0, 0x2(%rax)
movw $0x3e2d, (%rax)         # imm = 0x3E2D
jmp 0x1cfed
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 0x1cfba
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 0x1cf02
movq %rbx, %rdi
callq 0x4110
movw $0x2928, (%rbx,%rax)    # imm = 0x2928
movb $0x0, 0x2(%rbx,%rax)
jmp 0x1cfa3
movw $0x2e, (%rax)
movq 0x38(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1cf02
jmp 0x1cfa3
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r15
pushq $0x5
popq %r12
pushq $0x1
popq %r13
leaq 0xe2e4(%rip), %rbp      # 0x2b304
cmpl $0x3fff, %r15d          # imm = 0x3FFF
ja 0x1d139
movl %r15d, %eax
andl %ebx, %eax
leal -0x1(%rax), %ecx
cmpl $0x7, %ecx
jbe 0x1d09b
cmpl $0x10, %eax
je 0x1d0fd
cmpl $0x20, %eax
je 0x1d0e0
cmpl $0x40, %eax
je 0x1d0cb
cmpl $0x80, %eax
je 0x1d0d4
cmpl $0x100, %eax            # imm = 0x100
je 0x1d12e
cmpl $0x200, %eax            # imm = 0x200
je 0x1d106
cmpl $0x400, %eax            # imm = 0x400
je 0x1d0f4
cmpl $0x800, %eax            # imm = 0x800
je 0x1d0e9
cmpl $0x1000, %eax           # imm = 0x1000
je 0x1d123
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x1d11b
leaq 0xe48e(%rip), %rdi      # 0x2b527
jmp 0x1d0db
movslq (%rbp,%rcx,4), %rax
addq %rbp, %rax
jmpq *%rax
leaq 0xe41d(%rip), %rdi      # 0x2b4c9
jmp 0x1d0be
leaq 0xe425(%rip), %rdi      # 0x2b4da
jmp 0x1d10d
leaq 0xe417(%rip), %rdi      # 0x2b4d5
pushq $0x4
jmp 0x1d0dd
leaq 0xe405(%rip), %rdi      # 0x2b4ce
jmp 0x1d0db
leaq 0xe41a(%rip), %rdi      # 0x2b4ec
jmp 0x1d0db
leaq 0xe418(%rip), %rdi      # 0x2b4f3
pushq $0x6
popq %rsi
jmp 0x1d110
leaq 0xe3ff(%rip), %rdi      # 0x2b4e6
jmp 0x1d10d
leaq 0xe41c(%rip), %rdi      # 0x2b50c
pushq $0xc
jmp 0x1d0dd
leaq 0xe405(%rip), %rdi      # 0x2b500
jmp 0x1d10d
leaq 0xe3dc(%rip), %rdi      # 0x2b4e0
jmp 0x1d10d
leaq 0xe3f9(%rip), %rdi      # 0x2b506
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x42c0
addl %r15d, %r15d
jmp 0x1d020
leaq 0xe3ef(%rip), %rdi      # 0x2b519
pushq $0xd
jmp 0x1d0dd
leaq 0xe3c5(%rip), %rdi      # 0x2b4fa
pushq $0xb
jmp 0x1d0dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: set_u
static char *
set_u(struct symentry *x, char *nu)
{	char *u;

	if (!Fct_name) goto isglob;

	if (!x)
	{	u = (char *) e_malloc(strlen(nu)+strlen(Fct_name)+1-1);
		sprintf(u, "%s%s", Fct_name, &nu[1]);
	} else if (x->decl_level == 0)
	{	u = (char *) e_malloc(strlen(nu)+strlen("fct")+1-1);
		sprintf(u, "%s%s", "fct", &nu[1]);
	} else if (x->decl_level == 3)	/* is local */
	{	u = (char *) e_malloc(strlen(nu)+strlen(Fct_name)+1-1);
		sprintf(u, "%s%s", Fct_name, &nu[1]);
	} else	/* extern 1 or global 2 */
	{
isglob:		u = (char *) e_malloc(strlen(nu)+strlen("glob")+1-1);
		sprintf(u, "%s%s", "glob", &nu[1]);
	}
	return u;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x2d0bd(%rip), %r14     # 0x4af10
testq %r14, %r14
je 0x1de90
testq %rdi, %rdi
je 0x1deb6
movzwl 0x20(%rdi), %eax
cmpl $0x3, %eax
je 0x1deb6
testl %eax, %eax
jne 0x1de90
movq %rbx, %rdi
callq 0x4110
leal 0x3(%rax), %edi
callq 0x4739
movq %rax, %r14
incq %rbx
leaq 0xd54e(%rip), %rsi      # 0x2b3d5
leaq 0x2331(%rip), %rdx      # 0x201bf
jmp 0x1dee8
movq %rbx, %rdi
callq 0x4110
leal 0x4(%rax), %edi
callq 0x4739
movq %rax, %r14
incq %rbx
leaq 0xd528(%rip), %rsi      # 0x2b3d5
leaq 0xd786(%rip), %rdx      # 0x2b63a
jmp 0x1dee8
movq %rbx, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
addl %eax, %r15d
movl %r15d, %edi
callq 0x4739
movq %rax, %r14
movq 0x2d032(%rip), %rdx     # 0x4af10
incq %rbx
leaq 0xd4ed(%rip), %rsi      # 0x2b3d5
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x42a0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: merge_lists
static DefUse *
merge_lists(DefUse *d1, DefUse *d2)
{	DefUse *nd;

	if (!d1) return d2;
	if (!d2) return d1;

	nd = (DefUse *) e_malloc(sizeof(DefUse));
	if (!preview)
	{	nd->def   = merge_syms(d1->def, d2->def);
		nd->use   = merge_syms(d1->use, d2->use);
	}
	nd->other = merge_syms(d1->other, d2->other);

	return nd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x1df5f
movq %rdi, %r15
testq %r14, %r14
je 0x1df64
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %rbx
leaq 0x18b17(%rip), %rax     # 0x36a3c
cmpl $0x0, (%rax)
jne 0x1df4c
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
callq 0x1df70
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x1df70
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x1df70
movq %rax, 0x18(%rbx)
jmp 0x1df67
movq %r14, %rbx
jmp 0x1df67
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/dflow.c
// Function: merge_syms
static SymList *
merge_syms(SymList *s1, SymList *s2)
{	SymList *s, *t, *ns;
	SymList *add_to_s1 = (SymList *) 0;
	SymList *last_in   = (SymList *) 0;

	/* static int mcnt=1; */

	if (!s1) return s2;
	if (!s2) return s1;
#if 0
	printf("merge%d:\t", mcnt++);
	for (t = s1; t; t = t->nxt)
	printf("%s, ", t->sm->nme->str);
	printf("\nand:\t");
	for (t = s2; t; t = t->nxt)
	printf("%s, ", t->sm->nme->str);
	printf("\n\n");
	/* if (mcnt > 11) abort(); */
#endif

	for (t = s2; t; t = t->nxt)
	{	for (s = s1; s; s = s->nxt)
			if (s->sm == t->sm
			&&  s->mark == t->mark)
				break;

		if (!s) /* add t */
		{	ns = symadd(t->sm, t->mark);
			/* preserve relative order */
			if (!last_in)
				add_to_s1 = last_in = ns;
			else
			{	last_in->nxt = ns;
				last_in = ns;
			}
	}	}

	if (!last_in)
		return s1;

	last_in->nxt = s1;
	s1 = add_to_s1;
	return s1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdi, %rdi
je 0x1dfeb
movq %rdi, %rbx
testq %r15, %r15
je 0x1dfe6
xorl %r14d, %r14d
xorl %r12d, %r12d
testq %r15, %r15
je 0x1dfda
movq 0x8(%r15), %rdi
movq %rbx, %rax
testq %rax, %rax
je 0x1dfb4
cmpq %rdi, 0x8(%rax)
jne 0x1dfae
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
je 0x1dfce
movq 0x10(%rax), %rax
jmp 0x1df9a
movl 0x4(%r15), %esi
callq 0x1ccec
testq %r12, %r12
je 0x1dfc9
movq %rax, 0x10(%r12)
jmp 0x1dfd1
movq %rax, %r14
jmp 0x1dfd1
movq %r12, %rax
movq 0x10(%r15), %r15
movq %rax, %r12
jmp 0x1df8e
testq %r12, %r12
je 0x1dfe6
movq %rbx, 0x10(%r12)
jmp 0x1dfee
movq %rbx, %r14
jmp 0x1dfee
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/prnttree.c
// Function: print_recur
void
print_recur(treenode *root, FILE *fp)
{
	can_flush = fp;
	strcpy(PBuf, "");
	do_recur(root, 0);
	fprintf(fp, "%s", PBuf);
	can_flush = (FILE *) 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, 0x2cf12(%rip)     # 0x4af20
movb $0x0, 0x2cf1b(%rip)     # 0x4af30
leaq 0x2cf14(%rip), %r14     # 0x4af30
xorl %esi, %esi
callq 0x1e03e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
andq $0x0, 0x2ceea(%rip)     # 0x4af20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/prnttree.c
// Function: print2buf
char *
print2buf(treenode *root)
{	// small fragments
	strcpy(PBuf, "");
	do_recur(root, 0);
	return PBuf; // read only
}

// Assembly:
pushq %rbx
movb $0x0, 0x2c261(%rip)     # 0x4af30
leaq 0x2c25a(%rip), %rbx     # 0x4af30
xorl %esi, %esi
callq 0x1e03e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/prnttree.c
// Function: fput_meta
static void
fput_meta(int c, int in_str)
{	char s[2];

	switch (c) {
	case '\'':
		strcat(PBuf, in_str ? "'" : "\\'");
		break;
	case '"':
		strcat(PBuf, in_str ? "\\\"" : "\"");
		break;
	case '\0':
		strcat(PBuf, "\\0");
		break;
	case '\\':
		strcat(PBuf, "\\\\");
		break;
	case '\n':
		strcat(PBuf, "\\n");
		break;
	case '\t':
		strcat(PBuf, "\\t");
		break;
	case '\r':
		strcat(PBuf, "\\r");
		break;
	case '\f':
		strcat(PBuf, "\\f");
		break;
	case '\b':
		strcat(PBuf, "\\b");
		break;
	case '\v':
		strcat(PBuf, "\\v");
		break;
	case '\a':
		strcat(PBuf, "\\a");
		break;
	case '%':
		strcat(PBuf, "%%");	/* NEW */
		break;
	default:
		s[0] = c; s[1] = '\0';
		strcat(PBuf, s);
		break;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0xd, %edi
ja 0x1ed24
movl %edi, %eax
leaq 0xca4b(%rip), %rcx      # 0x2b74c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2c21f(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x305c, (%rax,%rbx)    # imm = 0x305C
jmp 0x1ee74
cmpl $0x22, %edi
je 0x1ee23
cmpl $0x25, %edi
je 0x1ee48
cmpl $0x5c, %edi
je 0x1ee5f
cmpl $0x27, %edi
jne 0x1ed59
testl %esi, %esi
leaq 0x3f3e(%rip), %rax      # 0x22c8b
leaq 0x8682(%rip), %rsi      # 0x273d6
jmp 0x1ee33
leaq 0xe(%rsp), %rsi
movb %dil, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0x2c1c4(%rip), %rdi     # 0x4af30
callq 0x4290
jmp 0x1ee79
leaq 0x2c1b3(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x765c, (%rax,%rbx)    # imm = 0x765C
jmp 0x1ee74
leaq 0x2c199(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x6e5c, (%rax,%rbx)    # imm = 0x6E5C
jmp 0x1ee74
leaq 0x2c17f(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x745c, (%rax,%rbx)    # imm = 0x745C
jmp 0x1ee74
leaq 0x2c165(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x665c, (%rax,%rbx)    # imm = 0x665C
jmp 0x1ee74
leaq 0x2c14b(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x615c, (%rax,%rbx)    # imm = 0x615C
jmp 0x1ee74
leaq 0x2c134(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x625c, (%rax,%rbx)    # imm = 0x625C
jmp 0x1ee74
leaq 0x2c11d(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x725c, (%rax,%rbx)    # imm = 0x725C
jmp 0x1ee74
testl %esi, %esi
leaq 0xcdb9(%rip), %rax      # 0x2bbe5
leaq 0x3e5b(%rip), %rsi      # 0x22c8e
cmoveq %rax, %rsi
leaq 0x2c0f2(%rip), %rdi     # 0x4af30
addq $0x10, %rsp
popq %rbx
jmp 0x4290
leaq 0x2c0e1(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x2525, (%rax,%rbx)    # imm = 0x2525
jmp 0x1ee74
leaq 0x2c0ca(%rip), %rbx     # 0x4af30
movq %rbx, %rdi
callq 0x4110
movw $0x5c5c, (%rax,%rbx)    # imm = 0x5C5C
movb $0x0, 0x2(%rax,%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/modex_pp.c
// Function: avoid_name_clash
static void
avoid_name_clash(char *p, char *s)
{	char *q;
	int n = strlen(s);
	int m = strlen(p);

	while (m > 0 && (q = strstr(p, s)) != NULL)
	{	if (*(q-1) != '_'
		&& !isalnum((int)*(q-1))
		&&  *(q+n) != '_'
		&& !isalnum((int)*(q+n)))
		{	*q = toupper((int) *q);
		}
		p = q+n;
		m = strlen(p);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
movslq %r15d, %r15
testl %eax, %eax
jle 0x1f4fd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
testq %rax, %rax
je 0x1f4fd
movq %rax, %r14
movsbq -0x1(%rax), %r12
cmpq $0x5f, %r12
je 0x1f4f0
callq 0x42e0
movq (%rax), %rax
testb $0x8, (%rax,%r12,2)
jne 0x1f4f0
movsbq (%r14,%r15), %rcx
cmpq $0x5f, %rcx
je 0x1f4f0
testb $0x8, (%rax,%rcx,2)
jne 0x1f4f0
movsbl (%r14), %edi
callq 0x40c0
movb %al, (%r14)
addq %r15, %r14
movq %r14, %rdi
callq 0x4110
jmp 0x1f4a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/USArmyResearchLab[P]ARL_OpenSHMEM/tools/oshrun.c
// Function: cleanup
int cleanup(void) {
	int rc = 0;
	char shm[64];
	int i = 0;
	while (1) {
		snprintf(shm, sizeof(shm), "/dev/shm/shmem_init.%d.%d", getpid(), i++);
		struct stat sb;
		if (!stat(shm, &sb)) {
			if (remove(shm)) rc = 1;
		}
		else return rc;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsp, %r14
pushq $0x40
popq %r15
leaq 0x48(%rsp), %r12
pushq $0x1
popq %rbx
xorl %ebp, %ebp
xorl %r13d, %r13d
callq 0x1050
movq %r14, %rdi
movq %r15, %rsi
leaq 0x101b(%rip), %rdx      # 0x229e
movl %eax, %ecx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movq %r12, %rsi
callq 0x10c0
testl %eax, %eax
jne 0x12b0
incl %r13d
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
cmovnel %ebx, %ebp
jmp 0x1271
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/./cmdtlv.h
// Function: dump_tlv_serialized_buffer
static inline void
dump_tlv_serialized_buffer(ser_buff_t *tlv_ser_buff){

    tlv_struct_t *tlv = NULL;

    printf("cmd code = %d\n", EXTRACT_CMD_CODE(tlv_ser_buff));
    TLV_LOOP_BEGIN(tlv_ser_buff, tlv){
        print_tlv_content(tlv);
        printf("\n");
    } TLV_LOOP_END;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x3fde
cltq
pushq $0x64
popq %r15
xorl %edx, %edx
divq %r15
imulq $0x64, %rax, %rax
leaq (%r14,%rax), %rdi
addq $-0x40, %rdi
callq 0x1220
leaq 0x5e10(%rip), %rdi      # 0x7202
movl %eax, %esi
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %r13
movq %rbx, %rdi
callq 0x3fde
cltq
xorl %edx, %edx
divq %r15
movq %rax, %rbx
decl %ebx
pushq $0xa
popq %rbp
leaq 0x5df5(%rip), %r14      # 0x7211
leaq 0x5e03(%rip), %r15      # 0x7226
leaq 0x5e11(%rip), %r12      # 0x723b
subl $0x1, %ebx
jb 0x1473
testq %r13, %r13
je 0x1466
movl (%r13), %edi
callq 0x1c6d
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x4(%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
leaq 0x24(%r13), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x10e0
movl %ebp, %edi
callq 0x1040
addq $0x64, %r13
jmp 0x142a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/testapp.c
// Function: user_vlan_validation_callback
int
user_vlan_validation_callback(char *vlan_id){

    int vlan_no = atoi(vlan_id);

    if(vlan_no > 0 && vlan_no < 4096)
        return 0;

    printf("Invalid vlan. Pls follow Help\n");
    return -1;
}

// Assembly:
pushq %rax
callq 0x1220
movl %eax, %ecx
decl %ecx
xorl %eax, %eax
cmpl $0xfff, %ecx            # imm = 0xFFF
jb 0x14c3
leaq 0x5d95(%rip), %rdi      # 0x7250
callq 0x1080
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: libcli_register_param
void
libcli_register_param(param_t *parent, param_t *child){
    
    int i = 0;
    if(!parent)
        parent = &root;
        
    if(!IS_PARAM_MODE_ENABLE(parent)){
        parent->options[MODE_PARAM_INDEX] = libcli_get_mode_param();
    }

    if(!IS_PARAM_SUBOPTIONS_ENABLE(parent)){
        parent->options[SUBOPTIONS_INDEX] = libcli_get_suboptions_param();
    }

    if(parent->options[CMD_EXPANSION_INDEX] == NULL)
        parent->options[CMD_EXPANSION_INDEX] = libcli_get_cmd_expansion_param();

    for(i = CHILDREN_START_INDEX; i <= CHILDREN_END_INDEX; i++){
        if(parent->options[i])
            continue;
        
        parent->options[i] = child;
        if(child != libcli_get_show_brief_extension_param())
            child->parent = parent;
        child->parent = parent;
        return;
    }

    printf("%s() : Error : No space for new command\n", __FUNCTION__);
    assert(0);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
leaq 0xbf5e(%rip), %rax      # 0xdaa8
cmovneq %rdi, %rax
cmpq $0x0, 0x60(%rax)
jne 0x1b60
leaq 0xbc64(%rip), %rcx      # 0xd7c0
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x68(%rax)
jne 0x1b72
leaq 0xbd4a(%rip), %rcx      # 0xd8b8
movq %rcx, 0x68(%rax)
cmpq $0x0, 0x70(%rax)
jne 0x1b84
leaq 0xbe30(%rip), %rcx      # 0xd9b0
movq %rcx, 0x70(%rax)
pushq $0xf
popq %rcx
cmpq $0x1c, %rcx
je 0x1ba9
leaq 0x1(%rcx), %rdx
cmpq $0x0, (%rax,%rcx,8)
movq %rdx, %rcx
jne 0x1b87
movq %rsi, -0x8(%rax,%rdx,8)
movq %rax, 0xe0(%rsi)
popq %rax
retq
leaq 0x5bf1(%rip), %rdi      # 0x77a1
leaq 0x5c13(%rip), %rsi      # 0x77ca
xorl %eax, %eax
callq 0x10e0
leaq 0x573c(%rip), %rdi      # 0x7301
leaq 0x56d4(%rip), %rsi      # 0x72a0
leaq 0x5c0d(%rip), %rcx      # 0x77e0
movl $0x253, %edx            # imm = 0x253
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: get_show_extension_type
show_ext_t
get_show_extension_type(ser_buff_t *b){
    
    assert(b);
    unsigned int tlv_units = get_serialize_buffer_size(b)/sizeof(tlv_struct_t);
    tlv_struct_t *show_ext_tlv = NULL;

    if(tlv_units == 0)
        return none;

    if(tlv_units == 1){
        show_ext_tlv = (tlv_struct_t *)(b->b);
    }
    else{
        show_ext_tlv = (tlv_struct_t *)(b->b) + (tlv_units -2);
    }
    assert(show_ext_tlv);

    if(strncmp(show_ext_tlv->leaf_id, SHOW_EXTENSION_PARAM, strlen(SHOW_EXTENSION_PARAM)))
        return none;
    if(strncmp(show_ext_tlv->value, SHOW_EXTENSION_PARAM_BRIEF, strlen(SHOW_EXTENSION_PARAM_BRIEF)) == 0)
        return brief;
    if(strncmp(show_ext_tlv->value, SHOW_EXTENSION_PARAM_DETAIL, strlen(SHOW_EXTENSION_PARAM_DETAIL)) == 0)
        return detail;
    if(strncmp(show_ext_tlv->value, SHOW_EXTENSION_PARAM_EXTENSIVE, strlen(SHOW_EXTENSION_PARAM_EXTENSIVE)) == 0)
        return extensive;
    assert(0);
    return none;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1d49
movq %rdi, %r14
callq 0x3fde
cltq
pushq $0x64
popq %rcx
xorl %edx, %edx
divq %rcx
pushq $0x3
popq %rbp
testl %eax, %eax
je 0x1d42
cmpl $0x1, %eax
jne 0x1cc7
movq (%r14), %rbx
jmp 0x1cd1
addl $-0x2, %eax
imulq $0x64, %rax, %rbx
addq (%r14), %rbx
testq %rbx, %rbx
je 0x1d68
leaq 0x4(%rbx), %rdi
leaq 0x56e5(%rip), %rsi      # 0x73ca
pushq $0xf
popq %rdx
callq 0x1070
testl %eax, %eax
jne 0x1d42
addq $0x24, %rbx
leaq 0x56de(%rip), %rsi      # 0x73da
pushq $0xa
popq %rdx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1d3b
leaq 0x56d3(%rip), %rsi      # 0x73e5
pushq $0xb
popq %rdx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1d3f
leaq 0x56c9(%rip), %rsi      # 0x73f1
pushq $0xe
popq %rdx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
jne 0x1d87
pushq $0x2
jmp 0x1d41
xorl %ebp, %ebp
jmp 0x1d42
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x563a(%rip), %rdi      # 0x738a
leaq 0x5549(%rip), %rsi      # 0x72a0
leaq 0x562e(%rip), %rcx      # 0x738c
movl $0xe5, %edx
callq 0x10f0
leaq 0x564e(%rip), %rdi      # 0x73bd
leaq 0x552a(%rip), %rsi      # 0x72a0
leaq 0x560f(%rip), %rcx      # 0x738c
movl $0xf2, %edx
callq 0x10f0
leaq 0x5573(%rip), %rdi      # 0x7301
leaq 0x550b(%rip), %rsi      # 0x72a0
leaq 0x55f0(%rip), %rcx      # 0x738c
movl $0xfc, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: set_device_name
void
set_device_name(const char *cons_name){
    
    char** tokens = NULL;
    size_t token_cnt = 0;    

    assert(cons_name);

    if(strlen(console_name))
        tokens = tokenizer(console_name, '>', &token_cnt);
    
    sprintf(console_name, "%s>", cons_name);
    
    if(token_cnt > 1){
        strcat(console_name, " ");
        string_space_trim(tokens[1]);
        strcat(console_name, tokens[1]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x2887
movq %rdi, %rbx
leaq 0xd5eb(%rip), %rax      # 0xfe00
cmpb $0x0, (%rax)
je 0x2833
leaq 0xd5df(%rip), %rdi      # 0xfe00
pushq $0x3e
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x46c6
movq %rax, %r14
jmp 0x2836
xorl %r14d, %r14d
leaq 0xd5c3(%rip), %r15      # 0xfe00
leaq 0x5c87(%rip), %rsi      # 0x84cb
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1250
cmpq $0x2, 0x8(%rsp)
jb 0x287d
movq %r15, %rdi
callq 0x10c0
movw $0x20, (%r15,%rax)
movq 0x8(%r14), %rdi
callq 0x4809
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4ee6(%rip), %rdi      # 0x7774
leaq 0x4a0b(%rip), %rsi      # 0x72a0
leaq 0x4ee2(%rip), %rcx      # 0x777e
movl $0x226, %edx            # imm = 0x226
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: ctrlC_signal_handler
static void
ctrlC_signal_handler(int sig){
    printf("Ctrl-C pressed\n");

    if (app_ctrlC_signal_handler) {
        app_ctrlC_signal_handler();
    }
    else {
        printf("Bye Bye\n");
        exit(0);
    }
}

// Assembly:
pushq %rax
leaq 0x50c4(%rip), %rdi      # 0x79a0
callq 0x1080
movq 0xbb80(%rip), %rax      # 0xe468
testq %rax, %rax
je 0x28f0
popq %rcx
jmpq *%rax
leaq 0x50b8(%rip), %rdi      # 0x79af
callq 0x1080
xorl %edi, %edi
callq 0x1260
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: support_cmd_negation
void
support_cmd_negation(param_t *param){
    
    int i = 0;
    assert(param);
    assert(get_current_branch_hook(param) == libcli_get_config_hook());

    param_t *negate_param = find_matching_param(&param->options[0], NEGATE_CHARACTER);

    if(negate_param && IS_PARAM_NO_CMD(negate_param)){
        printf("Error : Attempt to add Duplicate Negate param in cmd : %s\n", GET_CMD_NAME(param));
        return;
    }

    param_t *no_param = (param_t *)calloc(1, sizeof(param_t));
    init_param(no_param, NO_CMD, NEGATE_CHARACTER, negate_callback, 0, INVALID, 0, "Command Negation");
   
    /*We cant leave the MODE_PARAM_INDEX empty, 
     * so a hack - fill it with suboptions param. I dont see any implication of this.
     * We dont support MODE with negate cmd*/ 

    no_param->options[MODE_PARAM_INDEX] = libcli_get_suboptions_param();//libcli_get_mode_param();
    no_param->options[SUBOPTIONS_INDEX] = libcli_get_suboptions_param();
    no_param->options[CMD_EXPANSION_INDEX] = libcli_get_cmd_expansion_param();
     
    for(i = CHILDREN_START_INDEX; i <= CHILDREN_END_INDEX; i++){
        if(param->options[i]){
            no_param->options[i] = param->options[i];
            continue;
        }
        break;
    }

    assert(i <= CHILDREN_END_INDEX);
    param->options[i] = no_param;
    no_param->parent = param;
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2a06
movq %rdi, %rbx
callq 0x2a44
leaq 0xb65e(%rip), %rcx      # 0xdf80
cmpq %rcx, %rax
jne 0x2a25
leaq 0x60(%rbx), %rdi
leaq 0x4cbc(%rip), %rsi      # 0x75f2
callq 0x311f
testq %rax, %rax
je 0x295e
cmpl $0x2, (%rax)
jne 0x295e
movq 0x8(%rbx), %rsi
leaq 0x4dc0(%rip), %rdi      # 0x7710
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x10e0
pushq $0x1
popq %rdi
movl $0xf8, %esi
callq 0x1140
movq %rax, %r14
andq $0x0, (%rsp)
leaq 0x4dd1(%rip), %rax      # 0x774b
movq %rax, 0x8(%rsp)
leaq 0x4c6c(%rip), %rdx      # 0x75f2
leaq 0x281b(%rip), %rcx      # 0x51a8
pushq $0x2
popq %rsi
pushq $0x6
popq %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x26b6
leaq 0xaf12(%rip), %rax      # 0xd8b8
movq %rax, 0x60(%r14)
movq %rax, 0x68(%r14)
leaq 0xaffb(%rip), %rax      # 0xd9b0
movq %rax, 0x70(%r14)
pushq $0xf
popq %rax
cmpq $0x1c, %rax
je 0x29e7
movq (%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x29d4
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x29bc
movq %r14, (%rbx,%rax,8)
movq %rbx, 0xe0(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x4d6e(%rip), %rdi      # 0x775c
leaq 0x48ab(%rip), %rsi      # 0x72a0
leaq 0x4cb4(%rip), %rcx      # 0x76b0
movl $0x219, %edx            # imm = 0x219
callq 0x10f0
leaq 0x4f80(%rip), %rdi      # 0x798d
leaq 0x488c(%rip), %rsi      # 0x72a0
leaq 0x4c95(%rip), %rcx      # 0x76b0
movl $0x1fc, %edx            # imm = 0x1FC
callq 0x10f0
leaq 0x4ca9(%rip), %rdi      # 0x76d5
leaq 0x486d(%rip), %rsi      # 0x72a0
leaq 0x4c76(%rip), %rcx      # 0x76b0
movl $0x1fd, %edx            # imm = 0x1FD
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: get_current_branch_hook
param_t*
get_current_branch_hook(param_t *current_param){
    assert(current_param);
    assert(current_param != &root);
    while(current_param->parent != &root){
        current_param = current_param->parent;
    }
    return current_param;;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2a67
leaq 0xb057(%rip), %rcx      # 0xdaa8
cmpq %rcx, %rdi
je 0x2a86
movq %rdi, %rax
movq 0xe0(%rdi), %rdi
cmpq %rcx, %rdi
jne 0x2a56
popq %rcx
retq
leaq 0x4da3(%rip), %rdi      # 0x7811
leaq 0x482b(%rip), %rsi      # 0x72a0
leaq 0x4da3(%rip), %rcx      # 0x781f
movl $0x281, %edx            # imm = 0x281
callq 0x10f0
leaq 0x4dbe(%rip), %rdi      # 0x784b
leaq 0x480c(%rip), %rsi      # 0x72a0
leaq 0x4d84(%rip), %rcx      # 0x781f
movl $0x282, %edx            # imm = 0x282
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: dump_one_cmd
static void
_dump_one_cmd(param_t *param, unsigned short tabs){

    int i = 0;

    PRINT_TABS(tabs);

    if(IS_PARAM_CMD(param) || IS_PARAM_NO_CMD(param))
        printf("-->%s(%d)", GET_CMD_NAME(param), tabs);
    else
        printf("-->%s(%d)", GET_LEAF_TYPE_STR(param), tabs);

    for(; i < MAX_OPTION_SIZE; i++){
        if(param->options[i]){
            printf("\n");
            _dump_one_cmd(param->options[i], ++tabs);
            --tabs;
        }
        else
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x4ed0(%rip), %r14      # 0x7993
movl %ebp, %r15d
subw $0x1, %r15w
jb 0x2ad9
movq %r14, %rdi
xorl %eax, %eax
callq 0x10e0
jmp 0x2ac6
movzwl %bp, %r14d
testl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jne 0x2af2
movq 0x8(%rbx), %rsi
leaq 0x4ea6(%rip), %rdi      # 0x7996
jmp 0x2b07
movq 0x8(%rbx), %rax
movl (%rax), %edi
callq 0x1c6d
leaq 0x4e92(%rip), %rdi      # 0x7996
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10e0
incl %ebp
xorl %r15d, %r15d
pushq $0xa
popq %r14
movzwl %bp, %ebp
cmpq $0x10, %r15
je 0x2b44
cmpq $0x0, 0x60(%rbx,%r15,8)
je 0x2b44
movl %r14d, %edi
callq 0x1040
movq 0x60(%rbx,%r15,8), %rdi
movl %ebp, %esi
callq 0x2ab0
incq %r15
jmp 0x2b1d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: goto_top_of_cmd_tree
void
goto_top_of_cmd_tree(param_t *curr_cmd_tree_cursor){

    char** tokens = NULL;
    size_t token_cnt = 0;

    assert(curr_cmd_tree_cursor);
    
    if(curr_cmd_tree_cursor == &root){
        printf(ANSI_COLOR_BLUE "Info : At Roof top Already\n" ANSI_COLOR_RESET);
        return;
    }

    do{
        if(IS_PARAM_CMD(curr_cmd_tree_cursor)){
            curr_cmd_tree_cursor = curr_cmd_tree_cursor->parent;
            continue;
        }
        memset(GET_LEAF_VALUE_PTR(curr_cmd_tree_cursor), 0, LEAF_VALUE_HOLDER_SIZE);
        curr_cmd_tree_cursor = curr_cmd_tree_cursor->parent;
    } while(curr_cmd_tree_cursor != &root);
    
    reset_cmd_tree_cursor();
    tokens = tokenizer(console_name, '>', &token_cnt);
    sprintf(console_name, "%s>", tokens[0]);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x2be1
leaq 0xaf3d(%rip), %rax      # 0xdaa8
cmpq %rax, %rdi
je 0x2bce
xorps %xmm0, %xmm0
cmpl $0x0, (%rdi)
je 0x2b8c
movq 0x8(%rdi), %rcx
movups %xmm0, 0x34(%rcx)
movups %xmm0, 0x24(%rcx)
movups %xmm0, 0x14(%rcx)
movups %xmm0, 0x4(%rcx)
movq 0xe0(%rdi), %rdi
cmpq %rax, %rdi
jne 0x2b73
callq 0x1bdd
leaq 0xd25c(%rip), %rbx      # 0xfe00
pushq $0x3e
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x46c6
movq (%rax), %rdx
leaq 0x590d(%rip), %rsi      # 0x84cb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1250
addq $0x10, %rsp
popq %rbx
retq
leaq 0x4cc7(%rip), %rdi      # 0x789c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x10e0
leaq 0x4c7a(%rip), %rdi      # 0x7862
leaq 0x46b1(%rip), %rsi      # 0x72a0
leaq 0x4c81(%rip), %rcx      # 0x7877
movl $0x294, %edx            # imm = 0x294
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: go_one_level_up_cmd_tree
void
go_one_level_up_cmd_tree(param_t *curr_cmd_tree_cursor){

    char** tokens = NULL;
    size_t token_cnt = 0;

    assert(curr_cmd_tree_cursor);

    if(curr_cmd_tree_cursor == &root){
        printf(ANSI_COLOR_BLUE "Info : At Roof top Already\n" ANSI_COLOR_RESET);
        return;
    }

    if(IS_PARAM_LEAF(curr_cmd_tree_cursor)){
        memset(GET_LEAF_VALUE_PTR(curr_cmd_tree_cursor), 0, LEAF_VALUE_HOLDER_SIZE);
        serialize_buffer_skip(tlv_buff, -1 * (int)sizeof(tlv_struct_t));/*Rewind*/
        mark_checkpoint_serialize_buffer(tlv_buff);
    }

     set_cmd_tree_cursor(curr_cmd_tree_cursor->parent);

     if(get_cmd_tree_cursor() == &root){
        tokens = tokenizer(console_name, '>', &token_cnt);
        sprintf(console_name, "%s>", tokens[0]);
        reset_serialize_buffer(tlv_buff);
        return;
     }
    
     build_mode_console_name(get_cmd_tree_cursor());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x2cce
movq %rdi, %rbx
leaq 0xae8c(%rip), %r14      # 0xdaa8
cmpq %r14, %rdi
je 0x2c7c
cmpl $0x1, (%rbx)
jne 0x2c58
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x4(%rax)
movq 0xb81c(%rip), %rdi      # 0xe460
pushq $-0x64
popq %rsi
callq 0x3fe2
movq 0xb80d(%rip), %rdi      # 0xe460
callq 0x404e
movq 0xe0(%rbx), %rdi
callq 0x1bf7
movq 0xb7ed(%rip), %rdi      # 0xe458
cmpq %r14, %rdi
je 0x2c91
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ced
leaq 0x4c19(%rip), %rdi      # 0x789c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
leaq 0xd168(%rip), %rbx      # 0xfe00
pushq $0x3e
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x46c6
movq (%rax), %rdx
leaq 0x581b(%rip), %rsi      # 0x84cb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1250
movq 0xb79f(%rip), %rdi      # 0xe460
callq 0x45de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4b8d(%rip), %rdi      # 0x7862
leaq 0x45c4(%rip), %rsi      # 0x72a0
leaq 0x4bde(%rip), %rcx      # 0x78c1
movl $0x2af, %edx            # imm = 0x2AF
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/sachinites[P]CommandParser/cmd_hier.c
// Function: build_mode_console_name
void
build_mode_console_name(param_t *dst_param){

    assert(dst_param);
    assert(dst_param != &root);/*This fn should not be called for root*/

    int i = MAX_CMD_TREE_DEPTH -1;
    size_t token_cnt = 0;
    
    char** tokens = NULL;
    char *append_string = NULL;

    static char cmd_names[MAX_CMD_TREE_DEPTH][LEAF_VALUE_HOLDER_SIZE];
    char *admin_set_console_name = NULL;

    tokens = tokenizer(console_name, '>', &token_cnt);
    admin_set_console_name = tokens[0];
    sprintf(console_name, "%s> ", admin_set_console_name);
    
    do{
        assert(i != -1); 
        if(IS_PARAM_CMD(dst_param))
            append_string = GET_CMD_NAME(dst_param);
        else
            append_string = GET_LEAF_VALUE_PTR(dst_param);

        strncpy(cmd_names[i], append_string, strlen(append_string));
        i--;
        dst_param = dst_param->parent;
    }while(dst_param != &root);

    for(i = i+1; i < MAX_CMD_TREE_DEPTH -1; i++){
        strcat(console_name, cmd_names[i]);
        strcat(console_name, "-");
    }

    strcat(console_name, cmd_names[i]);
    memset(cmd_names, 0, MAX_CMD_TREE_DEPTH * LEAF_VALUE_HOLDER_SIZE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2e27
movq %rdi, %r14
leaq 0xad9d(%rip), %rax      # 0xdaa8
cmpq %rax, %rdi
je 0x2e46
movq %rsp, %rdx
andq $0x0, (%rdx)
leaq 0xd0de(%rip), %rbx      # 0xfe00
pushq $0x3e
popq %rsi
movq %rbx, %rdi
callq 0x46c6
movq (%rax), %rdx
leaq 0x4bf8(%rip), %rsi      # 0x792f
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1250
leaq 0xccb5(%rip), %rbp      # 0xfa00
leaq -0x40(%r12), %r13
cmpq $-0x440, %r13           # imm = 0xFBC0
je 0x2e08
xorl %r15d, %r15d
cmpl $0x0, (%r14)
setne %r15b
shll $0x2, %r15d
addq 0x8(%r14), %r15
addq %rbp, %r12
addq $0x3c0, %r12            # imm = 0x3C0
movq %r15, %rdi
callq 0x10c0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1060
movq 0xe0(%r14), %r14
movq %r13, %r12
leaq 0xad07(%rip), %rax      # 0xdaa8
cmpq %rax, %r14
jne 0x2d4b
jmp 0x2dcd
leaq 0x400(,%rbp), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x1240
movq %rbx, %rdi
callq 0x10c0
movw $0x2d, (%rbx,%rax)
addq $0x40, %r13
cmpq $-0x40, %r13
jne 0x2da8
leaq 0xd026(%rip), %rdi      # 0xfe00
leaq 0xcfdf(%rip), %rsi      # 0xfdc0
callq 0x1240
leaq 0xcc13(%rip), %rdi      # 0xfa00
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x1100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b25(%rip), %rdi      # 0x7934
leaq 0x448a(%rip), %rsi      # 0x72a0
leaq 0x4ad7(%rip), %rcx      # 0x78f4
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x10f0
leaq 0x4abc(%rip), %rdi      # 0x78ea
leaq 0x446b(%rip), %rsi      # 0x72a0
leaq 0x4ab8(%rip), %rcx      # 0x78f4
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10f0
leaq 0x4acf(%rip), %rdi      # 0x791c
leaq 0x444c(%rip), %rsi      # 0x72a0
leaq 0x4a99(%rip), %rcx      # 0x78f4
movl $0x2d0, %edx            # imm = 0x2D0
callq 0x10f0