LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1ea43
movq 0x1846f(%rip), %r15     # 0x36fd0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4190
movq 0x2eb6b(%rip), %r12     # 0x4d6e0
testq %r12, %r12
je 0x1ec00
leaq 0x78be(%rip), %r13      # 0x26443
leaq 0x8508(%rip), %rbp      # 0x27094
leaq 0xf9a3(%rip), %r14      # 0x2e536
cmpq $0x0, 0x10(%r12)
je 0x1ebf6
cmpl $0x0, 0xc(%r12)
je 0x1ebf6
movq (%r15), %rdi
movq (%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x85db(%rip), %rsi      # 0x27194
xorl %eax, %eax
callq 0x41c0
movq 0x10(%r12), %rbx
testq %rbx, %rbx
je 0x1ebf6
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
movq 0x10(%rbx), %rbx
jmp 0x1ebc5
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1eb93
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4190
movq 0x2eacc(%rip), %r14     # 0x4d6e0
testq %r14, %r14
je 0x1ec8d
leaq 0x1ae4c(%rip), %r12     # 0x39a6c
leaq 0x751f(%rip), %rbx      # 0x26146
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x1ec84
cmpl $0x0, 0xc(%r14)
je 0x1ec84
testb $0x2, (%r12)
sete %cl
movl %eax, %edx
notl %edx
testb $0x5, %dl
je 0x1ec84
shrl $0x9, %eax
andb %cl, %al
jne 0x1ec84
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1ec84
movq 0x18(%rsi), %rdi
callq 0x6b65
testl %eax, %eax
je 0x1ec84
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 0x1eab7
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x1ec27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ed28
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1ad78(%rip), %rax     # 0x39a2c
cmpl $0x0, (%rax)
jne 0x1ed1d
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x1ed29
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1ed1d
movq %r14, %rdi
movl $0x1, %esi
callq 0x1e966
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x1ed17
movq %rax, %r15
movq %r12, %rdi
movl $0x4, %esi
callq 0x1e966
movq 0x8(%r14), %rcx
cmpq 0x8(%r12), %rcx
je 0x1ed0d
movq %r15, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x1e9f3
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x1ece5
movq 0x10(%r14), %r14
jmp 0x1ecc7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1ecc3
movq %r14, %rdi
movl $0x4, %esi
callq 0x1e966
movq 0x10(%r14), %r14
jmp 0x1ed2d
// File: /workspace/github_c_makefile_star2_O1/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 0x1edd8
movl %esi, %ebp
movl %esi, %r14d
andl $0xfffffdff, %r14d      # imm = 0xFFFFFDFF
movl %r14d, %r15d
orl $0x1, %r15d
movq 0x2e966(%rip), %r12     # 0x4d6e0
testq %r12, %r12
je 0x1edcf
movq (%r12), %rax
cmpq 0x8(%r13), %rax
jne 0x1edc8
movl 0x8(%r12), %ecx
movl %ecx, %edx
notl %edx
testl %edx, %r15d
je 0x1edb9
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
leaq 0xf798(%rip), %rsi      # 0x2e541
movl $0x1, %r8d
movl %r14d, %r9d
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r12), %eax
orl %ebp, %eax
orl $0x1, %eax
movl %eax, 0x8(%r12)
movq 0x18(%r12), %r12
jmp 0x1ed7a
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1ed73
movq (%rsp), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x1ee3d
leaq 0xf772(%rip), %r14      # 0x2e55e
movq 0x2e8ed(%rip), %r12     # 0x4d6e0
testq %r12, %r12
je 0x1ee34
movq (%r12), %rax
cmpq 0x8(%r15), %rax
jne 0x1ee2d
movl 0x8(%r12), %ecx
testb $0x4, %cl
jne 0x1ee27
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %r8d
xorl %eax, %eax
callq 0x41c0
orb $0x4, 0x8(%r12)
movq 0x18(%r12), %r12
jmp 0x1edf3
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1edec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f1b8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdx)
jne 0x1f127
cmpq $0x0, 0x10(%rbx)
je 0x1f12f
movq %rbx, %rdi
callq 0x1ec9c
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x1f1b4
cmpq %rbx, %rax
je 0x1f1b8
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 0x1f186
movq 0x8(%rdx), %rsi
cmpq 0x8(%rcx), %rsi
jne 0x1f1c3
movq 0x10(%rcx), %rcx
movq 0x10(%rdx), %rdx
testq %rcx, %rcx
setne %sil
testq %rdx, %rdx
setne %dil
je 0x1f186
testq %rcx, %rcx
jne 0x1f15f
testb %dil, %dil
jne 0x1f1c3
testb %sil, %sil
jne 0x1f1c3
movq %rbx, %rcx
movq %rax, %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x1f1be
testq %rdx, %rdx
je 0x1f1be
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
je 0x1f196
jmp 0x1f1c3
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
orq %rdx, %rcx
je 0x1f232
leaq 0x17fc6(%rip), %rax     # 0x37190
movq (%rax), %rsi
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
leaq 0xf3b3(%rip), %rdi      # 0x2e58f
leaq 0x7eb1(%rip), %r8       # 0x27094
movq %r15, %r9
xorl %eax, %eax
callq 0x4140
leaq 0xf53f(%rip), %rdi      # 0x2e733
callq 0x40d0
movq 0x20(%r14), %rdi
movq 0x17dcc(%rip), %r14     # 0x36fd0
movq (%r14), %rsi
callq 0x1ee4c
leaq 0xf525(%rip), %rdi      # 0x2e738
callq 0x40d0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1ee4c
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 0x1f288
movq 0x8(%rcx), %rdx
cmpq 0x8(%rax), %rdx
jne 0x1f1c3
movl 0x4(%rcx), %edx
cmpl 0x4(%rax), %edx
jne 0x1f1c3
movq 0x10(%rax), %rax
movq 0x10(%rcx), %rcx
testq %rax, %rax
setne %dl
testq %rcx, %rcx
setne %sil
je 0x1f288
testq %rax, %rax
jne 0x1f252
testb %sil, %sil
jne 0x1f1c3
testb %dl, %dl
je 0x1f1b8
jmp 0x1f1c3
// File: /workspace/github_c_makefile_star2_O1/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 0x1a779(%rip), %rax     # 0x39a64
cmpl $0x0, (%rax)
jne 0x1f2fb
movq $0x0, 0x2e3fd(%rip) # 0x4d6f8
movl $0x20, %edi
callq 0x6469
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movl %ebx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq 0x2e3bf(%rip), %rax     # 0x4d6f8
movq %rax, 0x18(%r15)
movq %r15, 0x2e3b4(%rip)     # 0x4d6f8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f3aa
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1f34a
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1f37a
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x41b0
testl %eax, %eax
je 0x1f38e
movq (%r14), %rdx
leaq 0xf233(%rip), %rsi      # 0x2e5b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movl 0x8(%r14), %edx
leaq 0x54eb(%rip), %rsi      # 0x24884
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41c0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f3e3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0x1f3ab
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x1f34a
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4190
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f57d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x4, %eax
je 0x1f502
cmpl $0x1, %eax
jne 0x1f541
cmpl $0x2d, 0x1c(%r14)
jne 0x1f541
movq 0x30(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4280
jmp 0x1f566
movl 0x1c(%r14), %eax
cmpl $0x3, %eax
je 0x1f588
cmpl $0x27, %eax
jne 0x1f541
movq 0x30(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1f4c5
movl 0x18(%r14), %r15d
movq %rbx, %rdi
callq 0x4110
addq %rbx, %rax
cmpl $0x175, %r15d           # imm = 0x175
jne 0x1f5ab
movb $0x0, 0x2(%rax)
movw $0x3e2d, (%rax)         # imm = 0x3E2D
jmp 0x1f5b0
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 0x1f57d
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 0x1f4c5
movq %rbx, %rdi
callq 0x4110
movw $0x2928, (%rbx,%rax)    # imm = 0x2928
movb $0x0, 0x2(%rbx,%rax)
jmp 0x1f566
movw $0x2e, (%rax)
movq 0x38(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1f4c5
jmp 0x1f566
// File: /workspace/github_c_makefile_star2_O1/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 0xee2b(%rip), %r15      # 0x2e408
leaq 0xf029(%rip), %r12      # 0x2e60d
leaq 0xf030(%rip), %rbp      # 0x2e61b
movl %r13d, %eax
andl %ebx, %eax
cmpl $0x7f, %eax
jg 0x1f624
cmpl $0xf, %eax
jg 0x1f662
decl %eax
cmpl $0x7, %eax
ja 0x1f79e
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x4, %esi
movl $0x1, %edx
leaq 0xef9e(%rip), %rdi      # 0x2e5bd
jmp 0x1f796
cmpl $0x3ff, %eax            # imm = 0x3FF
jle 0x1f693
cmpl $0xfff, %eax            # imm = 0xFFF
jg 0x1f6ca
cmpl $0x400, %eax            # imm = 0x400
je 0x1f72a
cmpl $0x800, %eax            # imm = 0x800
jne 0x1f79e
movl $0xc, %esi
movl $0x1, %edx
leaq 0xefa3(%rip), %rdi      # 0x2e600
jmp 0x1f796
cmpl $0x10, %eax
je 0x1f74c
cmpl $0x20, %eax
je 0x1f772
cmpl $0x40, %eax
jne 0x1f79e
movl $0x6, %esi
movl $0x1, %edx
leaq 0xef52(%rip), %rdi      # 0x2e5e0
jmp 0x1f796
cmpl $0x80, %eax
je 0x1f75f
cmpl $0x100, %eax            # imm = 0x100
je 0x1f785
cmpl $0x200, %eax            # imm = 0x200
jne 0x1f79e
movl $0x5, %esi
movl $0x1, %edx
leaq 0xef35(%rip), %rdi      # 0x2e5fa
jmp 0x1f796
cmpl $0x1000, %eax           # imm = 0x1000
je 0x1f73d
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x1f79e
movl $0x6, %esi
movl $0x1, %edx
movq %rbp, %rdi
jmp 0x1f796
movl $0x6, %esi
movl $0x1, %edx
leaq 0xeec3(%rip), %rdi      # 0x2e5c2
jmp 0x1f796
movl $0x4, %esi
movl $0x1, %edx
leaq 0xeeb4(%rip), %rdi      # 0x2e5c9
jmp 0x1f796
movl $0x5, %esi
movl $0x1, %edx
leaq 0xeea6(%rip), %rdi      # 0x2e5ce
jmp 0x1f796
movl $0x5, %esi
movl $0x1, %edx
leaq 0xeeb9(%rip), %rdi      # 0x2e5f4
jmp 0x1f796
movl $0xd, %esi
movl $0x1, %edx
movq %r12, %rdi
jmp 0x1f796
movl $0x5, %esi
movl $0x1, %edx
leaq 0xee77(%rip), %rdi      # 0x2e5d4
jmp 0x1f796
movl $0x6, %esi
movl $0x1, %edx
leaq 0xee77(%rip), %rdi      # 0x2e5e7
jmp 0x1f796
movl $0x5, %esi
movl $0x1, %edx
leaq 0xee57(%rip), %rdi      # 0x2e5da
jmp 0x1f796
movl $0xb, %esi
movl $0x1, %edx
leaq 0xee58(%rip), %rdi      # 0x2e5ee
movq %r14, %rcx
callq 0x42b0
leal (,%r13,2), %eax
cmpl $0x2000, %r13d          # imm = 0x2000
movl %eax, %r13d
jb 0x1f5eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2da84(%rip), %r14     # 0x4df00
testq %r14, %r14
je 0x204b9
testq %rdi, %rdi
je 0x204df
movzwl 0x20(%rdi), %eax
cmpl $0x3, %eax
je 0x204df
testl %eax, %eax
jne 0x204b9
movq %rbx, %rdi
callq 0x4110
leal 0x3(%rax), %edi
callq 0x6469
movq %rax, %r14
incq %rbx
leaq 0xe019(%rip), %rsi      # 0x2e4c9
leaq 0x2d08(%rip), %rdx      # 0x231bf
jmp 0x20511
movq %rbx, %rdi
callq 0x4110
leal 0x4(%rax), %edi
callq 0x6469
movq %rax, %r14
incq %rbx
leaq 0xdff3(%rip), %rsi      # 0x2e4c9
leaq 0xe251(%rip), %rdx      # 0x2e72e
jmp 0x20511
movq %rbx, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
addl %eax, %r15d
movl %r15d, %edi
callq 0x6469
movq %rax, %r14
movq 0x2d9f9(%rip), %rdx     # 0x4df00
incq %rbx
leaq 0xdfb8(%rip), %rsi      # 0x2e4c9
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4290
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2058a
movq %rdi, %r15
testq %r14, %r14
je 0x2058f
movl $0x20, %edi
callq 0x6469
movq %rax, %rbx
leaq 0x194dc(%rip), %rax     # 0x39a2c
cmpl $0x0, (%rax)
jne 0x20577
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
callq 0x2059b
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x2059b
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x2059b
movq %rax, 0x18(%rbx)
jmp 0x20592
movq %r14, %rbx
jmp 0x20592
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x2063e
movq %rdi, %rbx
testq %r14, %r14
je 0x20639
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq %rbx, %rcx
cmpq %rax, 0x8(%rcx)
jne 0x205d6
movl 0x4(%rcx), %edx
cmpl 0x4(%r14), %edx
je 0x20624
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x205c7
movq 0x8(%r14), %r13
movl 0x4(%r14), %ebp
movl $0x20, %edi
callq 0x6469
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
movq %r13, 0x8(%rax)
movq 0x2d0e9(%rip), %rcx     # 0x4d6f0
movq %rcx, 0x18(%rax)
movq %rax, 0x2d0de(%rip)     # 0x4d6f0
testq %r12, %r12
je 0x2061e
movq %rax, 0x10(%r12)
jmp 0x20621
movq %rax, %r15
movq %rax, %r12
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x205c0
testq %r12, %r12
je 0x20639
movq %rbx, 0x10(%r12)
jmp 0x20641
movq %rbx, %r15
jmp 0x20641
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, 0x2d8ae(%rip)     # 0x4df10
movb $0x0, 0x2d8b7(%rip)     # 0x4df20
leaq 0x2d8b0(%rip), %r14     # 0x4df20
xorl %esi, %esi
callq 0x20695
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
movq $0x0, 0x2d883(%rip) # 0x4df10
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x2cb8b(%rip)     # 0x4df20
leaq 0x2cb84(%rip), %rbx     # 0x4df20
xorl %esi, %esi
callq 0x20695
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x21, %edi
jg 0x2142f
cmpl $0xd, %edi
ja 0x21576
movl %edi, %eax
leaq 0xd434(%rip), %rcx      # 0x2e840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2cb04(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x305c, (%rax,%rbx)    # imm = 0x305C
jmp 0x2156b
cmpl $0x26, %edi
jg 0x21460
cmpl $0x22, %edi
je 0x21531
cmpl $0x25, %edi
jne 0x21576
leaq 0x2cad3(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x2525, (%rax,%rbx)    # imm = 0x2525
jmp 0x2156b
cmpl $0x5c, %edi
je 0x21556
cmpl $0x27, %edi
jne 0x21576
testl %esi, %esi
leaq 0x4910(%rip), %rax      # 0x25d8b
leaq 0x9044(%rip), %rsi      # 0x2a4c6
jmp 0x21541
leaq 0x2ca92(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x725c, (%rax,%rbx)    # imm = 0x725C
jmp 0x2156b
leaq 0x2ca78(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x6e5c, (%rax,%rbx)    # imm = 0x6E5C
jmp 0x2156b
leaq 0x2ca5e(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x745c, (%rax,%rbx)    # imm = 0x745C
jmp 0x2156b
leaq 0x2ca44(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x625c, (%rax,%rbx)    # imm = 0x625C
jmp 0x2156b
leaq 0x2ca2d(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x765c, (%rax,%rbx)    # imm = 0x765C
jmp 0x2156b
leaq 0x2ca16(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x615c, (%rax,%rbx)    # imm = 0x615C
jmp 0x2156b
leaq 0x2c9ff(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x665c, (%rax,%rbx)    # imm = 0x665C
jmp 0x2156b
testl %esi, %esi
leaq 0xd79f(%rip), %rax      # 0x2ecd9
leaq 0x484d(%rip), %rsi      # 0x25d8e
cmoveq %rax, %rsi
leaq 0x2c9d4(%rip), %rdi     # 0x4df20
addq $0x10, %rsp
popq %rbx
jmp 0x4280
leaq 0x2c9c3(%rip), %rbx     # 0x4df20
movq %rbx, %rdi
callq 0x4110
movw $0x5c5c, (%rax,%rbx)    # imm = 0x5C5C
movb $0x0, 0x2(%rax,%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0xe(%rsp), %rsi
movb %dil, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0x2c997(%rip), %rdi     # 0x4df20
callq 0x4280
jmp 0x21570
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x4110
testl %eax, %eax
jle 0x21bea
movq %rbx, %rdi
callq 0x4110
movslq %eax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42c0
testq %rax, %rax
je 0x21bea
movq %rax, %r14
movsbq -0x1(%rax), %r12
cmpq $0x5f, %r12
je 0x21bdb
callq 0x42d0
movq (%rax), %rax
testb $0x8, (%rax,%r12,2)
jne 0x21bdb
movsbq (%r14,%r15), %rcx
cmpq $0x5f, %rcx
je 0x21bdb
testb $0x8, (%rax,%rcx,2)
jne 0x21bdb
movsbl (%r14), %edi
callq 0x40c0
movb %al, (%r14)
addq %r15, %r14
movq %r14, %rdi
callq 0x4110
testl %eax, %eax
jg 0x21b91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x48(%rsp), %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
callq 0x1050
movl $0x40, %esi
movq %r14, %rdi
leaq 0xfd0(%rip), %rdx       # 0x229e
movl %eax, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movq %r15, %rsi
callq 0x10c0
movl %eax, %r13d
testl %eax, %eax
je 0x12f0
movl %ebp, %ebx
jmp 0x1302
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
movl $0x1, %eax
cmovnel %eax, %ebp
incl %r12d
testl %r13d, %r13d
je 0x12ba
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
callq 0x44e6
cltq
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %r14 # imm = 0x28F5C28F5C28F5C3
mulq %r14
shrq $0x2, %rdx
imulq $0x64, %rdx, %rax
leaq (%r15,%rax), %rdi
addq $-0x40, %rdi
callq 0x1210
leaq 0x6e16(%rip), %rdi      # 0x8202
movl %eax, %esi
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %r13
movq %rbx, %rdi
callq 0x44e6
cltq
shrq $0x2, %rax
mulq %r14
movq %rdx, %rbx
shrq $0x2, %rbx
decl %ebx
je 0x1472
leaq 0x6df6(%rip), %r14      # 0x8211
leaq 0x6e04(%rip), %r15      # 0x8226
leaq 0x6e12(%rip), %r12      # 0x823b
testq %r13, %r13
je 0x1460
movl (%r13), %edi
callq 0x1cfd
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 $0xa, %edi
callq 0x1040
addq $0x64, %r13
decl %ebx
jne 0x1429
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1210
movl %eax, %ecx
decl %ecx
xorl %eax, %eax
cmpl $0xfff, %ecx            # imm = 0xFFF
jb 0x14bf
leaq 0x6d9b(%rip), %rdi      # 0x8250
callq 0x1080
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcede(%rip), %rax      # 0xeaa8
cmovneq %rdi, %rax
cmpq $0x0, 0x60(%rax)
jne 0x1be0
leaq 0xcbe4(%rip), %rcx      # 0xe7c0
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x68(%rax)
jne 0x1bf2
leaq 0xccca(%rip), %rcx      # 0xe8b8
movq %rcx, 0x68(%rax)
cmpq $0x0, 0x70(%rax)
jne 0x1c04
leaq 0xcdb0(%rip), %rcx      # 0xe9b0
movq %rcx, 0x70(%rax)
movl $0xf, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x1c4d
incq %rcx
cmpq $0x1c, %rcx
jne 0x1c09
leaq 0x6b81(%rip), %rdi      # 0x87a1
leaq 0x6ba3(%rip), %rsi      # 0x87ca
xorl %eax, %eax
callq 0x10e0
leaq 0x66cc(%rip), %rdi      # 0x8301
leaq 0x6664(%rip), %rsi      # 0x82a0
leaq 0x6b9d(%rip), %rcx      # 0x87e0
movl $0x253, %edx            # imm = 0x253
callq 0x10f0
movq %rsi, (%rax,%rcx,8)
leaq 0xd708(%rip), %rcx      # 0xf360
cmpq %rcx, %rsi
je 0x1c64
movq %rax, 0xe0(%rsi)
movq %rax, 0xe0(%rsi)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e10
movq %rdi, %r14
callq 0x44e6
cltq
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movl $0x3, %ebp
testl %edx, %edx
je 0x1d8b
cmpl $0x1, %edx
jne 0x1d5f
movq (%r14), %rbx
jmp 0x1d69
addl $-0x2, %edx
imulq $0x64, %rdx, %rbx
addq (%r14), %rbx
testq %rbx, %rbx
je 0x1e2f
leaq 0x4(%rbx), %rdi
leaq 0x664d(%rip), %rsi      # 0x83ca
movl $0xf, %edx
callq 0x1070
testl %eax, %eax
je 0x1d92
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
addq $0x24, %rbx
leaq 0x663d(%rip), %rsi      # 0x83da
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1e02
leaq 0x6630(%rip), %rsi      # 0x83e5
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1e06
leaq 0x6624(%rip), %rsi      # 0x83f1
movl $0xe, %edx
movq %rbx, %rdi
callq 0x1070
movl $0x2, %ebp
testl %eax, %eax
je 0x1d8b
leaq 0x6517(%rip), %rdi      # 0x8301
leaq 0x64af(%rip), %rsi      # 0x82a0
leaq 0x6594(%rip), %rcx      # 0x838c
movl $0xfc, %edx
callq 0x10f0
xorl %ebp, %ebp
jmp 0x1d8b
movl $0x1, %ebp
jmp 0x1d8b
leaq 0x6573(%rip), %rdi      # 0x838a
leaq 0x6482(%rip), %rsi      # 0x82a0
leaq 0x6567(%rip), %rcx      # 0x838c
movl $0xe5, %edx
callq 0x10f0
leaq 0x6587(%rip), %rdi      # 0x83bd
leaq 0x6463(%rip), %rsi      # 0x82a0
leaq 0x6548(%rip), %rcx      # 0x838c
movl $0xf2, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x2ada
movq %rdi, %rbx
leaq 0xe39a(%rip), %rax      # 0x10e00
cmpb $0x0, (%rax)
je 0x2a86
leaq 0xe38e(%rip), %rdi      # 0x10e00
leaq 0x8(%rsp), %rdx
movl $0x3e, %esi
callq 0x4bf1
movq %rax, %r14
jmp 0x2a89
xorl %r14d, %r14d
leaq 0xe370(%rip), %r15      # 0x10e00
leaq 0x6a50(%rip), %rsi      # 0x94e7
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1240
cmpq $0x2, 0x8(%rsp)
jb 0x2ad0
movq %r15, %rdi
callq 0x10c0
movw $0x20, (%r15,%rax)
movq 0x8(%r14), %rdi
callq 0x4d5c
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1230
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c93(%rip), %rdi      # 0x8774
leaq 0x57b8(%rip), %rsi      # 0x82a0
leaq 0x5c8f(%rip), %rcx      # 0x877e
movl $0x226, %edx            # imm = 0x226
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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 0x5e71(%rip), %rdi      # 0x89a0
callq 0x1080
movq 0xc92d(%rip), %rax      # 0xf468
testq %rax, %rax
je 0x2b43
popq %rcx
jmpq *%rax
leaq 0x5e65(%rip), %rdi      # 0x89af
callq 0x1080
xorl %edi, %edi
callq 0x1250
// File: /workspace/github_c_makefile_star2_O1/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 0x2cf6
leaq 0xbdc8(%rip), %rcx      # 0xeaa8
cmpq %rcx, %rdi
je 0x2d15
movq %rdi, %rax
movq 0xe0(%rdi), %rdi
cmpq %rcx, %rdi
jne 0x2ce5
popq %rcx
retq
leaq 0x5b14(%rip), %rdi      # 0x8811
leaq 0x559c(%rip), %rsi      # 0x82a0
leaq 0x5b14(%rip), %rcx      # 0x881f
movl $0x281, %edx            # imm = 0x281
callq 0x10f0
leaq 0x5b2f(%rip), %rdi      # 0x884b
leaq 0x557d(%rip), %rsi      # 0x82a0
leaq 0x5af5(%rip), %rcx      # 0x881f
movl $0x282, %edx            # imm = 0x282
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0x2d69
leaq 0x5c3c(%rip), %r15      # 0x8993
movl %r14d, %ebp
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
decw %bp
jne 0x2d5a
movzwl %r14w, %edx
testl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jne 0x2dc3
movq 0x8(%rbx), %rsi
leaq 0x5c16(%rip), %rdi      # 0x8996
xorl %eax, %eax
callq 0x10e0
leal 0x1(%r14), %eax
xorl %r14d, %r14d
movzwl %ax, %ebp
cmpq $0x0, 0x60(%rbx,%r14,8)
je 0x2db8
movl $0xa, %edi
callq 0x1040
movq 0x60(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0x2d3f
incq %r14
cmpq $0x10, %r14
jne 0x2d91
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movl (%rax), %eax
cmpq $0x7, %rax
ja 0x2ddc
leaq 0x9fda(%rip), %rcx      # 0xcdb0
movq (%rcx,%rax,8), %rsi
jmp 0x2d79
leaq 0x559f(%rip), %rsi      # 0x8382
jmp 0x2d79
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x2e8e
leaq 0xbca0(%rip), %rax      # 0xeaa8
cmpq %rax, %rdi
je 0x2e7b
xorps %xmm0, %xmm0
cmpl $0x0, (%rdi)
je 0x2e29
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 0x2e10
movq %rax, 0xc61c(%rip)      # 0xf458
movq 0xc61d(%rip), %rdi      # 0xf460
callq 0x4b10
leaq 0xdfb1(%rip), %rbx      # 0x10e00
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4bf1
movq (%rax), %rdx
leaq 0x667c(%rip), %rsi      # 0x94e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5a1a(%rip), %rdi      # 0x889c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x10e0
leaq 0x59cd(%rip), %rdi      # 0x8862
leaq 0x5404(%rip), %rsi      # 0x82a0
leaq 0x59d4(%rip), %rcx      # 0x8877
movl $0x294, %edx            # imm = 0x294
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x2f86
movq %rdi, %rbx
leaq 0xbbdc(%rip), %r14      # 0xeaa8
cmpq %r14, %rdi
je 0x2f32
cmpl $0x1, (%rbx)
jne 0x2f0a
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x4(%rax)
movq 0xc56c(%rip), %rdi      # 0xf460
movl $0xffffff9c, %esi       # imm = 0xFFFFFF9C
callq 0x44ea
movq 0xc55b(%rip), %rdi      # 0xf460
callq 0x4557
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x2fa5
movq %rdi, 0xc537(%rip)      # 0xf458
cmpq %r14, %rdi
je 0x2f47
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2fc4
leaq 0x5963(%rip), %rdi      # 0x889c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
leaq 0xdeb2(%rip), %rbx      # 0x10e00
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4bf1
movq (%rax), %rdx
leaq 0x657f(%rip), %rsi      # 0x94e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
movq 0xc4e7(%rip), %rdi      # 0xf460
callq 0x4b10
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x58d5(%rip), %rdi      # 0x8862
leaq 0x530c(%rip), %rsi      # 0x82a0
leaq 0x5926(%rip), %rcx      # 0x88c1
movl $0x2af, %edx            # imm = 0x2AF
callq 0x10f0
leaq 0x59e1(%rip), %rdi      # 0x898d
leaq 0x52ed(%rip), %rsi      # 0x82a0
leaq 0x5323(%rip), %rcx      # 0x82dd
movl $0x8d, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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 0x3100
movq %rdi, %r15
leaq 0xbac6(%rip), %rbp      # 0xeaa8
cmpq %rbp, %rdi
je 0x311f
movq %rsp, %rdx
movq $0x0, (%rdx)
leaq 0xde04(%rip), %rbx      # 0x10e00
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4bf1
movq (%rax), %rdx
leaq 0x591c(%rip), %rsi      # 0x892f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
movq $-0x10, %r13
leaq 0xddd5(%rip), %r14      # 0x10e00
testq %r13, %r13
je 0x30e1
xorl %r12d, %r12d
cmpl $0x0, (%r15)
setne %r12b
shll $0x2, %r12d
addq 0x8(%r15), %r12
addq $-0x40, %r14
movq %r12, %rdi
callq 0x10c0
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1060
movq 0xe0(%r15), %r15
incq %r13
cmpq %rbp, %r15
jne 0x302b
movq %r13, %rax
negq %rax
cmpq $0xe, %rax
jg 0x30a7
addq $0xf, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1230
movq %rbx, %rdi
callq 0x10c0
movw $0x2d, (%rbx,%rax)
addq $0x40, %r14
decq %r13
jne 0x3080
movl $0xf, %eax
movl %eax, %esi
shlq $0x6, %rsi
leaq 0xd94c(%rip), %rbx      # 0x10a00
addq %rbx, %rsi
leaq 0xdd42(%rip), %rdi      # 0x10e00
callq 0x1230
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x584c(%rip), %rdi      # 0x8934
leaq 0x51b1(%rip), %rsi      # 0x82a0
leaq 0x57fe(%rip), %rcx      # 0x88f4
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x10f0
leaq 0x57e3(%rip), %rdi      # 0x88ea
leaq 0x5192(%rip), %rsi      # 0x82a0
leaq 0x57df(%rip), %rcx      # 0x88f4
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10f0
leaq 0x57f6(%rip), %rdi      # 0x891c
leaq 0x5173(%rip), %rsi      # 0x82a0
leaq 0x57c0(%rip), %rcx      # 0x88f4
movl $0x2d0, %edx            # imm = 0x2D0
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/sachinites[P]CommandParser/parser.c
// Function: parse_file
void
parse_file(char *file_name) {

	char line[256];
	char** tokens = NULL;
	size_t token_cnt = 0;

	FILE *fptr = fopen(file_name, "r");
	
	if (!fptr) {
	
		printf("Error : Could not open log file %s, errno = %d\n",
				file_name, errno);
		return;
	}

	memset(line, 0, sizeof(line));

	cmd_recording_enabled = false;
	reset_serialize_buffer(tlv_buff);

	while (fgets(line, sizeof(line) - 1, fptr)) {

		printf("Executing : %s", line);
	
		tokens = tokenizer(line, ' ', &token_cnt);		

		reset_serialize_buffer(tlv_buff);
		build_tlv_buffer(tokens, token_cnt);
		re_init_tokens(MAX_CMD_TREE_DEPTH);

		if (is_user_in_cmd_mode())
			restore_checkpoint_serialize_buffer(tlv_buff);
		else
			reset_serialize_buffer(tlv_buff);

		memset(line, 0, sizeof(line));
	}
	
	fclose(fptr);
	place_console(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
leaq 0x44d0(%rip), %rsi      # 0x859c
callq 0x11f0
testq %rax, %rax
je 0x41ea
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x1100
movb $0x1, 0xe5bc(%rip)      # 0x126b4
leaq 0xb361(%rip), %rbp      # 0xf460
movq (%rbp), %rdi
callq 0x4b10
movq %r14, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x1130
testq %rax, %rax
je 0x41b1
leaq 0x4a15(%rip), %r14      # 0x8b3d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r15, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0x4bf1
movq %rax, %r13
movq (%rbp), %rdi
callq 0x4b10
movq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x3a51
movl $0x10, %edi
callq 0x4b51
xorl %eax, %eax
callq 0x1cbc
movq (%rbp), %rdi
testl %eax, %eax
je 0x4188
callq 0x452b
jmp 0x418d
callq 0x4b10
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
movq %r15, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x1130
testq %rax, %rax
jne 0x4132
movq %rbx, %rdi
callq 0x1090
movl $0xa, %edi
callq 0x1040
leaq 0x4827(%rip), %rdi      # 0x89f1
leaq 0xcc2f(%rip), %rsi      # 0x10e00
xorl %eax, %eax
callq 0x10e0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050
movl (%rax), %edx
leaq 0x4915(%rip), %rdi      # 0x8b0d
movq %r14, %rsi
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O1/sachinites[P]CommandParser/serialize.c
// Function: init_serialized_buffer
void 
init_serialized_buffer(ser_buff_t **b){
    (*b) = (ser_buff_t *)calloc(1, sizeof(ser_buff_t));
    (*b)->b = calloc(1, SERIALIZE_BUFFER_DEFAULT_SIZE);
    (*b)->size = SERIALIZE_BUFFER_DEFAULT_SIZE;
    (*b)->next = 0;
    (*b)->checkpoint = 0;
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x1140
movq %rax, %r14
movq %rax, (%rbx)
movl $0x1, %edi
movl $0x200, %esi            # imm = 0x200
callq 0x1140
movq %rax, (%r14)
movq $0x200, 0x8(%r14)       # imm = 0x200
movl $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sachinites[P]CommandParser/serialize.c
// Function: init_serialized_buffer_of_defined_size
void
init_serialized_buffer_of_defined_size(ser_buff_t **b, int size){
    (*b) = (ser_buff_t *)calloc(1, sizeof(ser_buff_t));
    (*b)->b = calloc(1, size);
    (*b)->size = size;
    (*b)->next = 0;
    (*b)->checkpoint = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x1140
movq %rax, %r15
movq %rax, (%r14)
movslq %ebx, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1140
movq %rax, (%r15)
movl %ebx, 0x8(%r15)
movq $0x0, 0xc(%r15)
popq %rbx
popq %r14
popq %r15
retq