LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x2d48c(%rip), %r14     # 0x4cf10
testq %r14, %r14
je 0x1fac1
testq %rdi, %rdi
je 0x1fae7
movzwl 0x20(%rdi), %eax
cmpl $0x3, %eax
je 0x1fae7
testl %eax, %eax
jne 0x1fac1
movq %rbx, %rdi
callq 0x4110
leal 0x3(%rax), %edi
callq 0x6321
movq %rax, %r14
incq %rbx
leaq 0xd9fd(%rip), %rsi      # 0x2d4b5
leaq 0x2700(%rip), %rdx      # 0x221bf
jmp 0x1fb19
movq %rbx, %rdi
callq 0x4110
leal 0x4(%rax), %edi
callq 0x6321
movq %rax, %r14
incq %rbx
leaq 0xd9d7(%rip), %rsi      # 0x2d4b5
leaq 0xdc35(%rip), %rdx      # 0x2d71a
jmp 0x1fb19
movq %rbx, %rdi
callq 0x4110
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
addl %eax, %r15d
movl %r15d, %edi
callq 0x6321
movq %rax, %r14
movq 0x2d401(%rip), %rdx     # 0x4cf10
incq %rbx
leaq 0xd99c(%rip), %rsi      # 0x2d4b5
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_O3/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 0x1fb92
movq %rdi, %r15
testq %r14, %r14
je 0x1fb97
movl $0x20, %edi
callq 0x6321
movq %rax, %rbx
leaq 0x18ee4(%rip), %rax     # 0x38a3c
cmpl $0x0, (%rax)
jne 0x1fb7f
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
callq 0x1fba3
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x1fba3
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x1fba3
movq %rax, 0x18(%rbx)
jmp 0x1fb9a
movq %r14, %rbx
jmp 0x1fb9a
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1fc42
movq %rdi, %rbx
testq %r14, %r14
je 0x1fc3d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%r14), %r13
movq %rbx, %rax
cmpq %r13, 0x8(%rax)
jne 0x1fbde
movl 0x4(%rax), %ecx
cmpl 0x4(%r14), %ecx
je 0x1fc28
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1fbcf
movl 0x4(%r14), %ebp
movl $0x20, %edi
callq 0x6321
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
movq %r13, 0x8(%rax)
movq 0x2caf5(%rip), %rcx     # 0x4c700
movq %rcx, 0x18(%rax)
movq %rax, 0x2caea(%rip)     # 0x4c700
testq %r12, %r12
je 0x1fc22
movq %rax, 0x10(%r12)
jmp 0x1fc25
movq %rax, %r15
movq %rax, %r12
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1fbc8
testq %r12, %r12
je 0x1fc3d
movq %rbx, 0x10(%r12)
jmp 0x1fc45
movq %rbx, %r15
jmp 0x1fc45
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_O3/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, 0x2d2ba(%rip)     # 0x4cf20
movb $0x0, 0x2d2c3(%rip)     # 0x4cf30
leaq 0x2d2bc(%rip), %r14     # 0x4cf30
xorl %esi, %esi
callq 0x1fc99
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
movq $0x0, 0x2d28f(%rip) # 0x4cf20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x2c579(%rip)     # 0x4cf30
leaq 0x2c572(%rip), %rbx     # 0x4cf30
xorl %esi, %esi
callq 0x1fc99
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20a51
cmpl $0xd, %edi
ja 0x20b98
movl %edi, %eax
leaq 0xcdfe(%rip), %rcx      # 0x2d82c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2c4f2(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x305c, (%rax,%rbx)    # imm = 0x305C
jmp 0x20b8d
cmpl $0x26, %edi
jg 0x20a82
cmpl $0x22, %edi
je 0x20b53
cmpl $0x25, %edi
jne 0x20b98
leaq 0x2c4c1(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x2525, (%rax,%rbx)    # imm = 0x2525
jmp 0x20b8d
cmpl $0x5c, %edi
je 0x20b78
cmpl $0x27, %edi
jne 0x20b98
testl %esi, %esi
leaq 0x42ee(%rip), %rax      # 0x24d8b
leaq 0x8a22(%rip), %rsi      # 0x294c6
jmp 0x20b63
leaq 0x2c480(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x725c, (%rax,%rbx)    # imm = 0x725C
jmp 0x20b8d
leaq 0x2c466(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x6e5c, (%rax,%rbx)    # imm = 0x6E5C
jmp 0x20b8d
leaq 0x2c44c(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x745c, (%rax,%rbx)    # imm = 0x745C
jmp 0x20b8d
leaq 0x2c432(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x625c, (%rax,%rbx)    # imm = 0x625C
jmp 0x20b8d
leaq 0x2c41b(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x765c, (%rax,%rbx)    # imm = 0x765C
jmp 0x20b8d
leaq 0x2c404(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x615c, (%rax,%rbx)    # imm = 0x615C
jmp 0x20b8d
leaq 0x2c3ed(%rip), %rbx     # 0x4cf30
movq %rbx, %rdi
callq 0x4110
movw $0x665c, (%rax,%rbx)    # imm = 0x665C
jmp 0x20b8d
testl %esi, %esi
leaq 0xd169(%rip), %rax      # 0x2dcc5
leaq 0x422b(%rip), %rsi      # 0x24d8e
cmoveq %rax, %rsi
leaq 0x2c3c2(%rip), %rdi     # 0x4cf30
addq $0x10, %rsp
popq %rbx
jmp 0x4290
leaq 0x2c3b1(%rip), %rbx     # 0x4cf30
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 0x2c385(%rip), %rdi     # 0x4cf30
callq 0x4290
jmp 0x20b92
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x21221
movq %rbx, %rdi
callq 0x4110
movslq %eax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
testq %rax, %rax
je 0x21221
movq %rax, %r14
movsbq -0x1(%rax), %r12
cmpq $0x5f, %r12
je 0x21212
callq 0x42e0
movq (%rax), %rax
testb $0x8, (%rax,%r12,2)
jne 0x21212
movsbq (%r14,%r15), %rcx
cmpq $0x5f, %rcx
je 0x21212
testb $0x8, (%rax,%rcx,2)
jne 0x21212
movsbl (%r14), %edi
callq 0x40c0
movb %al, (%r14)
addq %r15, %r14
movq %r14, %rdi
callq 0x4110
testl %eax, %eax
jg 0x211c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x1050
leaq 0xfe5(%rip), %rdx       # 0x229e
xorl %ebx, %ebx
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movl %eax, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1070
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0x133a
movl $0x1, %r13d
movq %rsp, %r14
leaq 0xfab(%rip), %r15       # 0x229e
leaq 0x48(%rsp), %r12
movl $0x1, %ebp
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
cmovnel %r13d, %ebx
callq 0x1050
movl $0x40, %esi
movq %r14, %rdi
movq %r15, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movq %r12, %rsi
callq 0x10c0
incl %ebp
testl %eax, %eax
je 0x12ff
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_O3/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)
movq %rax, 0xe0(%rsi)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1dfd
movq %rdi, %r14
callq 0x439a
cltq
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movl $0x3, %ebp
testl %edx, %edx
je 0x1d78
cmpl $0x1, %edx
jne 0x1d4c
movq (%r14), %rbx
jmp 0x1d56
addl $-0x2, %edx
imulq $0x64, %rdx, %rbx
addq (%r14), %rbx
testq %rbx, %rbx
je 0x1e1c
leaq 0x4(%rbx), %rdi
leaq 0x6660(%rip), %rsi      # 0x83ca
movl $0xf, %edx
callq 0x1070
testl %eax, %eax
je 0x1d7f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
addq $0x24, %rbx
leaq 0x6650(%rip), %rsi      # 0x83da
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1def
leaq 0x6643(%rip), %rsi      # 0x83e5
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1070
testl %eax, %eax
je 0x1df3
leaq 0x6637(%rip), %rsi      # 0x83f1
movl $0xe, %edx
movq %rbx, %rdi
callq 0x1070
movl $0x2, %ebp
testl %eax, %eax
je 0x1d78
leaq 0x652a(%rip), %rdi      # 0x8301
leaq 0x64c2(%rip), %rsi      # 0x82a0
leaq 0x65a7(%rip), %rcx      # 0x838c
movl $0xfc, %edx
callq 0x10f0
xorl %ebp, %ebp
jmp 0x1d78
movl $0x1, %ebp
jmp 0x1d78
leaq 0x6586(%rip), %rdi      # 0x838a
leaq 0x6495(%rip), %rsi      # 0x82a0
leaq 0x657a(%rip), %rcx      # 0x838c
movl $0xe5, %edx
callq 0x10f0
leaq 0x659a(%rip), %rdi      # 0x83bd
leaq 0x6476(%rip), %rsi      # 0x82a0
leaq 0x655b(%rip), %rcx      # 0x838c
movl $0xf2, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac0
movq %rdi, %rbx
leaq 0xe3b4(%rip), %rax      # 0x10e00
cmpb $0x0, (%rax)
je 0x2a6c
leaq 0xe3a8(%rip), %rdi      # 0x10e00
leaq 0x8(%rsp), %rdx
movl $0x3e, %esi
callq 0x4a91
movq %rax, %r14
jmp 0x2a6f
xorl %r14d, %r14d
leaq 0xe38a(%rip), %r15      # 0x10e00
leaq 0x6a2d(%rip), %rsi      # 0x94aa
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1240
cmpq $0x2, 0x8(%rsp)
jb 0x2ab6
movq %r15, %rdi
callq 0x10c0
movw $0x20, (%r15,%rax)
movq 0x8(%r14), %rdi
callq 0x4bfe
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1230
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5cad(%rip), %rdi      # 0x8774
leaq 0x57d2(%rip), %rsi      # 0x82a0
leaq 0x5ca9(%rip), %rcx      # 0x877e
movl $0x226, %edx            # imm = 0x226
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x5e8b(%rip), %rdi      # 0x89a0
callq 0x1080
movq 0xc947(%rip), %rax      # 0xf468
testq %rax, %rax
je 0x2b29
popq %rcx
jmpq *%rax
leaq 0x5e7f(%rip), %rdi      # 0x89af
callq 0x1080
xorl %edi, %edi
callq 0x1250
// File: /workspace/github_c_makefile_star2_O3/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 0x2cdc
leaq 0xbde2(%rip), %rcx      # 0xeaa8
cmpq %rcx, %rdi
je 0x2cfb
movq %rdi, %rax
movq 0xe0(%rdi), %rdi
cmpq %rcx, %rdi
jne 0x2ccb
popq %rcx
retq
leaq 0x5b2e(%rip), %rdi      # 0x8811
leaq 0x55b6(%rip), %rsi      # 0x82a0
leaq 0x5b2e(%rip), %rcx      # 0x881f
movl $0x281, %edx            # imm = 0x281
callq 0x10f0
leaq 0x5b49(%rip), %rdi      # 0x884b
leaq 0x5597(%rip), %rsi      # 0x82a0
leaq 0x5b0f(%rip), %rcx      # 0x881f
movl $0x282, %edx            # imm = 0x282
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x2d4f
leaq 0x5c56(%rip), %r15      # 0x8993
movl %r14d, %ebp
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
decw %bp
jne 0x2d40
movzwl %r14w, %edx
testl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jne 0x2da9
movq 0x8(%rbx), %rsi
leaq 0x5c30(%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 0x2d9e
movl $0xa, %edi
callq 0x1040
movq 0x60(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0x2d25
incq %r14
cmpq $0x10, %r14
jne 0x2d77
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movl (%rax), %eax
cmpq $0x7, %rax
ja 0x2dc2
leaq 0x9ff4(%rip), %rcx      # 0xcdb0
movq (%rcx,%rax,8), %rsi
jmp 0x2d5f
leaq 0x55b9(%rip), %rsi      # 0x8382
jmp 0x2d5f
// File: /workspace/github_c_makefile_star2_O3/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 0x2e74
leaq 0xbcba(%rip), %rax      # 0xeaa8
cmpq %rax, %rdi
je 0x2e61
xorps %xmm0, %xmm0
cmpl $0x0, (%rdi)
je 0x2e0f
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 0x2df6
movq %rax, 0xc636(%rip)      # 0xf458
movq 0xc637(%rip), %rdi      # 0xf460
callq 0x49b2
leaq 0xdfcb(%rip), %rbx      # 0x10e00
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4a91
movq (%rax), %rdx
leaq 0x6659(%rip), %rsi      # 0x94aa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5a34(%rip), %rdi      # 0x889c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x10e0
leaq 0x59e7(%rip), %rdi      # 0x8862
leaq 0x541e(%rip), %rsi      # 0x82a0
leaq 0x59ee(%rip), %rcx      # 0x8877
movl $0x294, %edx            # imm = 0x294
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x2f6c
movq %rdi, %rbx
leaq 0xbbf6(%rip), %r14      # 0xeaa8
cmpq %r14, %rdi
je 0x2f18
cmpl $0x1, (%rbx)
jne 0x2ef0
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x4(%rax)
movq 0xc586(%rip), %rdi      # 0xf460
movl $0xffffff9c, %esi       # imm = 0xFFFFFF9C
callq 0x439e
movq 0xc575(%rip), %rdi      # 0xf460
callq 0x440a
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x2f8b
movq %rdi, 0xc551(%rip)      # 0xf458
cmpq %r14, %rdi
je 0x2f2d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2faa
leaq 0x597d(%rip), %rdi      # 0x889c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
leaq 0xdecc(%rip), %rbx      # 0x10e00
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4a91
movq (%rax), %rdx
leaq 0x655c(%rip), %rsi      # 0x94aa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
movq 0xc501(%rip), %rdi      # 0xf460
callq 0x49b2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x58ef(%rip), %rdi      # 0x8862
leaq 0x5326(%rip), %rsi      # 0x82a0
leaq 0x5940(%rip), %rcx      # 0x88c1
movl $0x2af, %edx            # imm = 0x2AF
callq 0x10f0
leaq 0x59fb(%rip), %rdi      # 0x898d
leaq 0x5307(%rip), %rsi      # 0x82a0
leaq 0x533d(%rip), %rcx      # 0x82dd
movl $0x8d, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x30e6
movq %rdi, %r15
leaq 0xbae0(%rip), %rbp      # 0xeaa8
cmpq %rbp, %rdi
je 0x3105
movq %rsp, %rdx
movq $0x0, (%rdx)
leaq 0xde1e(%rip), %rbx      # 0x10e00
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x4a91
movq (%rax), %rdx
leaq 0x5936(%rip), %rsi      # 0x892f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
movq $-0x10, %r13
leaq 0xddef(%rip), %r14      # 0x10e00
testq %r13, %r13
je 0x30c7
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 0x3011
movq %r13, %rax
negq %rax
cmpq $0xe, %rax
jg 0x308d
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 0x3066
movl $0xf, %eax
movl %eax, %esi
shlq $0x6, %rsi
leaq 0xd966(%rip), %rbx      # 0x10a00
addq %rbx, %rsi
leaq 0xdd5c(%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 0x5866(%rip), %rdi      # 0x8934
leaq 0x51cb(%rip), %rsi      # 0x82a0
leaq 0x5818(%rip), %rcx      # 0x88f4
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x10f0
leaq 0x57fd(%rip), %rdi      # 0x88ea
leaq 0x51ac(%rip), %rsi      # 0x82a0
leaq 0x57f9(%rip), %rcx      # 0x88f4
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10f0
leaq 0x5810(%rip), %rdi      # 0x891c
leaq 0x518d(%rip), %rsi      # 0x82a0
leaq 0x57da(%rip), %rcx      # 0x88f4
movl $0x2d0, %edx            # imm = 0x2D0
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x460d(%rip), %rsi      # 0x859c
callq 0x11f0
testq %rax, %rax
je 0x40ad
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x1100
movb $0x1, 0xe6f9(%rip)      # 0x126b4
leaq 0xb49e(%rip), %rbp      # 0xf460
movq (%rbp), %rdi
callq 0x49b2
movq %r14, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x1130
testq %rax, %rax
je 0x4074
leaq 0x4b15(%rip), %r14      # 0x8b00
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 0x4a91
movq %rax, %r13
movq (%rbp), %rdi
callq 0x49b2
movq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x39ce
movl $0x10, %edi
callq 0x49f1
xorl %eax, %eax
callq 0x1ca9
movq (%rbp), %rdi
testl %eax, %eax
je 0x404b
callq 0x43de
jmp 0x4050
callq 0x49b2
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 0x3ff5
movq %rbx, %rdi
callq 0x1090
movl $0xa, %edi
callq 0x1040
leaq 0x492a(%rip), %rdi      # 0x89b7
leaq 0xcd6c(%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 0x4a15(%rip), %rdi      # 0x8ad0
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_O3/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)
movl $0x200, 0x8(%r14)       # imm = 0x200
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_buffer_skip
void
serialize_buffer_skip(ser_buff_t *b, int size){
	int available_size = b->size - b->next;

	if(available_size >= size){
		b->next += size;
		return;
	}

	while(available_size < size){
		b->size = b->size * 2;
		available_size = b->size - b->next;
	}	

	b->b = realloc(b->b, b->size);	
	b->next += size;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
movl %ecx, %edx
subl %eax, %edx
cmpl %esi, %edx
jge 0x43d2
addl %ecx, %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl %ebp, %edx
jl 0x43b4
movl %ecx, 0x8(%rbx)
movq (%rbx), %rdi
movslq %ecx, %rsi
callq 0x11d0
movq %rax, (%rbx)
movl 0xc(%rbx), %eax
addl %ebp, %eax
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_int
void serialize_int(ser_buff_t *b, int data){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < sizeof(int)){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, &data, sizeof(int));
        buff->next += sizeof(int);
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, &data, sizeof(int));
    buff->next += sizeof(int);
    return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4492
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rcx
movl %eax, %edx
subl %ecx, %edx
cmpl $0x3, %edx
ja 0x447c
addl %eax, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl $0x4, %edx
jb 0x4457
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movslq %eax, %rsi
callq 0x11d0
movq %rax, (%rbx)
movslq 0xc(%rbx), %rcx
movl %ebp, (%rax,%rcx)
jmp 0x4485
movq (%rbx), %rax
movl %ebp, (%rax,%rcx)
movl 0xc(%rbx), %ecx
addl $0x4, %ecx
movl %ecx, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3e68(%rip), %rdi      # 0x8301
leaq 0x484a(%rip), %rsi      # 0x8cea
leaq 0x48ba(%rip), %rcx      # 0x8d61
movl $0x5b, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_int8
void serialize_int8(ser_buff_t *b, char data){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < sizeof(char)){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, &data, sizeof(char));
        buff->next += sizeof(char);
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, &data, sizeof(char));
    buff->next += sizeof(char);
    return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x44fb
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x8(%rdi), %rsi
movslq 0xc(%rdi), %rax
cmpl %eax, %esi
jne 0x44e5
addq %rsi, %rsi
movl %esi, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x11d0
movq %rax, (%rbx)
movslq 0xc(%rbx), %rcx
movb %bpl, (%rax,%rcx)
jmp 0x44ef
movq (%rbx), %rcx
movb %bpl, (%rcx,%rax)
movl 0xc(%rbx), %ecx
incl %ecx
movl %ecx, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3dff(%rip), %rdi      # 0x8301
leaq 0x47e1(%rip), %rsi      # 0x8cea
leaq 0x4877(%rip), %rcx      # 0x8d87
movl $0x75, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_uint32
void serialize_uint32(ser_buff_t *b, unsigned int data){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < sizeof(unsigned int)){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, &data, sizeof(unsigned int));
        buff->next += sizeof(unsigned int);
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, &data, sizeof(unsigned int));
    buff->next += sizeof(unsigned int);
    return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4652
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rcx
movl %eax, %edx
subl %ecx, %edx
cmpl $0x3, %edx
ja 0x463c
addl %eax, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl $0x4, %edx
jb 0x4617
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movslq %eax, %rsi
callq 0x11d0
movq %rax, (%rbx)
movslq 0xc(%rbx), %rcx
movl %ebp, (%rax,%rcx)
jmp 0x4645
movq (%rbx), %rax
movl %ebp, (%rax,%rcx)
movl 0xc(%rbx), %ecx
addl $0x4, %ecx
movl %ecx, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3ca8(%rip), %rdi      # 0x8301
leaq 0x468a(%rip), %rsi      # 0x8cea
leaq 0x4799(%rip), %rcx      # 0x8e00
movl $0xc1, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_float
void serialize_float(ser_buff_t *b, float data){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < sizeof(float)){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, &data, sizeof(float));
        buff->next += sizeof(float);
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, &data, sizeof(float));
    buff->next += sizeof(float);
    return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x46d8
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rcx
movl %eax, %edx
subl %ecx, %edx
cmpl $0x3, %edx
ja 0x46c1
movss %xmm0, 0xc(%rsp)
addl %eax, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl $0x4, %edx
jb 0x4694
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movslq %eax, %rsi
callq 0x11d0
movq %rax, (%rbx)
movslq 0xc(%rbx), %rcx
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax,%rcx)
jmp 0x46cc
movq (%rbx), %rax
movss %xmm0, (%rax,%rcx)
movl 0xc(%rbx), %ecx
addl $0x4, %ecx
movl %ecx, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3c22(%rip), %rdi      # 0x8301
leaq 0x4604(%rip), %rsi      # 0x8cea
leaq 0x4745(%rip), %rcx      # 0x8e32
movl $0xdc, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_double
void serialize_double(ser_buff_t *b, double data){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < sizeof(double)){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, &data, sizeof(double));
        buff->next += sizeof(double);
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, &data, sizeof(double));
    buff->next += sizeof(double);
    return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x475e
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rcx
movl %eax, %edx
subl %ecx, %edx
cmpl $0x7, %edx
ja 0x4747
movsd %xmm0, 0x8(%rsp)
addl %eax, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl $0x8, %edx
jb 0x471a
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movslq %eax, %rsi
callq 0x11d0
movq %rax, (%rbx)
movslq 0xc(%rbx), %rcx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx)
jmp 0x4752
movq (%rbx), %rax
movsd %xmm0, (%rax,%rcx)
movl 0xc(%rbx), %ecx
addl $0x8, %ecx
movl %ecx, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3b9c(%rip), %rdi      # 0x8301
leaq 0x457e(%rip), %rsi      # 0x8cea
leaq 0x46e9(%rip), %rcx      # 0x8e5c
movl $0xf7, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: serialize_string
void serialize_string(ser_buff_t *b, char *data, int nbytes){
    if (b == NULL) assert(0);
    ser_buff_t *buff = (ser_buff_t *)(b);
    int available_size = buff->size - buff->next;
    char isResize = 0;

    while(available_size < nbytes){
        buff->size = buff->size * 2;
        available_size = buff->size - buff->next;
        isResize = 1;
    }

    if(isResize == 0){
        memcpy((char *)buff->b + buff->next, data, nbytes);
        buff->next += nbytes;
        return;
    }

    // resize of the buffer
    buff->b = realloc(buff->b, buff->size); 
    memcpy((char *)buff->b + buff->next, data, nbytes);
    buff->next += nbytes;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x47f9
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rdi
movl %eax, %ecx
subl %edi, %ecx
cmpl %edx, %ecx
jge 0x47d4
addl %eax, %eax
movl %eax, %ecx
subl %edi, %ecx
cmpl %ebx, %ecx
jl 0x47a1
movl %eax, 0x8(%r14)
movq (%r14), %rdi
movslq %eax, %rsi
callq 0x11d0
movq %rax, (%r14)
movslq 0xc(%r14), %r12
movq %r12, %rdi
addq %rax, %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x1190
jmp 0x47e6
addq (%r14), %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x1190
movl 0xc(%r14), %r12d
addl %ebx, %r12d
movl %r12d, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3b01(%rip), %rdi      # 0x8301
leaq 0x44e3(%rip), %rsi      # 0x8cea
leaq 0x467a(%rip), %rcx      # 0x8e88
movl $0x110, %edx            # imm = 0x110
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: truncate_serialize_buffer
void truncate_serialize_buffer(ser_buff_t **b){
	ser_buff_t *clone = NULL;

	if((*b)->next == (*b)->size){
		return;
	}
	init_serialized_buffer_of_defined_size(&clone, (*b)->next);
	memcpy(clone->b, (*b)->b, (*b)->next);
	clone->next = clone->size;
	free_serialize_buffer(*b);
	*b = clone;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movl 0xc(%r14), %ebp
cmpl 0x8(%r14), %ebp
je 0x4887
movq %rdi, %rbx
movslq %ebp, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x1140
movq %rax, %r12
movl $0x1, %edi
movq %r15, %rsi
callq 0x1140
movq %rax, (%r12)
movl %ebp, 0x8(%r12)
movq (%r14), %r13
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1190
movl %ebp, 0xc(%r12)
movq %r13, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: print_buffer_details
void print_buffer_details(ser_buff_t *b, const char *fn, int lineno){
#if 1
    printf("%s():%d : starting address = %p\n", fn, lineno, b);
    printf("size = %d\n", b->size);
    printf("next = %d\n", b->next);
#endif
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4618(%rip), %rdi      # 0x8eb9
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movl 0x8(%rbx), %esi
leaq 0x4625(%rip), %rdi      # 0x8eda
xorl %eax, %eax
callq 0x10e0
movl 0xc(%rbx), %esi
leaq 0x461f(%rip), %rdi      # 0x8ee5
xorl %eax, %eax
popq %rbx
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: de_serialize_string
void 
de_serialize_string(char *dest, ser_buff_t *b, int size){
	if(!b || !b->b) assert(0);
	if(!size) assert(0);;
	if((b->size - b->next)< size) assert(0);	 
	memcpy(dest, b->b + b->next, size);
	b->next += size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x490d
movq %rsi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x490d
movl %edx, %ebx
testl %edx, %edx
je 0x492c
movl 0x8(%r14), %ecx
movslq 0xc(%r14), %rax
subl %eax, %ecx
cmpl %ebx, %ecx
jl 0x494b
addq %rax, %rsi
movslq %ebx, %rdx
callq 0x1190
addl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x39ed(%rip), %rdi      # 0x8301
leaq 0x43cf(%rip), %rsi      # 0x8cea
leaq 0x45ce(%rip), %rcx      # 0x8ef0
movl $0x143, %edx            # imm = 0x143
callq 0x10f0
leaq 0x39ce(%rip), %rdi      # 0x8301
leaq 0x43b0(%rip), %rsi      # 0x8cea
leaq 0x45af(%rip), %rcx      # 0x8ef0
movl $0x144, %edx            # imm = 0x144
callq 0x10f0
leaq 0x39af(%rip), %rdi      # 0x8301
leaq 0x4391(%rip), %rsi      # 0x8cea
leaq 0x4590(%rip), %rcx      # 0x8ef0
movl $0x145, %edx            # imm = 0x145
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/serialize.c
// Function: copy_in_serialized_buffer_by_offset
void copy_in_serialized_buffer_by_offset(ser_buff_t *b, int size, char *value, int offset){
	if((b->size - b->next) < size){
		printf("%s(): Error : Insufficient buffer space\n", __FUNCTION__);
		return;
	}
	
	if(offset > b->size){
		printf("%s(): Error : Attemt to write outside buffer boundaries\n", __FUNCTION__);
		return;
	}
	
	memcpy(b->b + offset, value, size);
}

// Assembly:
movl 0x8(%rdi), %eax
movl %eax, %r8d
subl 0xc(%rdi), %r8d
cmpl %esi, %r8d
jge 0x4982
leaq 0x45a4(%rip), %rdi      # 0x8f24
jmp 0x498d
cmpl %ecx, %eax
jge 0x499b
leaq 0x45e4(%rip), %rdi      # 0x8f71
leaq 0x45b9(%rip), %rsi      # 0x8f4d
xorl %eax, %eax
jmp 0x10e0
movslq %ecx, %rax
addq (%rdi), %rax
movslq %esi, %rcx
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/string_util.c
// Function: tokenizer
char** tokenizer(char* _a_str, const char a_delim, size_t *token_cnt){
   
    char *token = NULL;
    int i = 0;
    char delim[2];
    memset(a_str, 0, CONS_INPUT_BUFFER_SIZE);
    strncpy(a_str, _a_str, strlen(_a_str));
    a_str[strlen(_a_str)] = '\0';

    string_space_trim(a_str);

    if(strlen(a_str) < 1){
        *token_cnt = 0;
        return NULL;
    }

    delim[0] = a_delim;
    delim[1] = '\0';

    token = strtok(a_str, delim);
    if(token){
        untokenize(i);
        strncpy(tokens[i], token, strlen(token));
        i++;
    }
    else{
        *token_cnt = 0;
        return NULL;
    }
    
    /* walk through other tokens */
    while( token != NULL ) 
    {
        token = strtok(NULL, delim);
        if(token){
            untokenize(i);
            strncpy(tokens[i], token, strlen(token));
            i++;
            if(i == MAX_CMD_TREE_DEPTH + 1){
                //printf("Warning : Max token limit (= %d) support exceeded\n", MAX_CMD_TREE_DEPTH);
                re_init_tokens(MAX_CMD_TREE_DEPTH);
                *token_cnt = 0;
                return &tokens[0];
            }
        }
    } 
    *token_cnt = i;
    return &tokens[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
leaq 0xdcf5(%rip), %r15      # 0x127a0
xorl %ebx, %ebx
movl $0x800, %edx            # imm = 0x800
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
movq %r14, %rdi
callq 0x10c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1060
movq %r14, %rdi
callq 0x10c0
movb $0x0, (%rax,%r15)
movq %r15, %rdi
callq 0x4bfe
cmpb $0x0, 0xdcb2(%rip)      # 0x127a0
je 0x4be0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0xdc99(%rip), %rdi      # 0x127a0
callq 0x1200
testq %rax, %rax
je 0x4bde
movq %rax, %r14
movq %r12, %rbp
movq 0xdbfe(%rip), %rax      # 0x12720
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq 0xdbe5(%rip), %r15      # 0x12720
movq %r14, %rdi
callq 0x10c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1060
movl $0x1, %ebx
leaq 0x6(%rsp), %r15
leaq 0xdbbe(%rip), %r14      # 0x12720
xorl %edi, %edi
movq %r15, %rsi
callq 0x1200
testq %rax, %rax
je 0x4be5
movq %rax, %r12
movq (%r14,%rbx,8), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r14,%rbx,8), %r13
movq %r12, %rdi
callq 0x10c0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1060
incq %rbx
cmpl $0x11, %ebx
jne 0x4b62
xorl %ebx, %ebx
leaq 0xdb6b(%rip), %r14      # 0x12720
xorps %xmm0, %xmm0
xorl %eax, %eax
movq %rbp, %r12
movq (%rax,%r14), %rcx
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
addq $0x8, %rax
cmpq $0x80, %rax
jne 0x4bbd
jmp 0x4be8
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4be8
movq %rbp, %r12
movq %rbx, (%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sachinites[P]CommandParser/string_util.c
// Function: string_space_trim
void
string_space_trim(char *string){

    if(!string)
        return;

    char* ptr = string;
    int len = strlen(ptr);

    if(!len){
        return;
    }

    if(!isspace(ptr[0]) && !isspace(ptr[len-1])){
        return;
    }

    while(len-1 > 0 && isspace(ptr[len-1])){
        ptr[--len] = 0;
    }

    while(*ptr && isspace(*ptr)){
        ++ptr, --len;
    }

    memmove(string, ptr, len + 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4c3e
movq %rdi, %rbx
callq 0x10c0
movq %rax, %r14
testl %r14d, %r14d
je 0x4c3e
callq 0x1290
movq (%rax), %rdx
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x4c46
movl %r14d, %esi
decl %esi
movslq %esi, %rsi
movsbq (%rbx,%rsi), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x4c46
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2, %r14d
jl 0x4c81
leal -0x1(%r14), %ecx
addq %rbx, %rcx
movq (%rax), %rdx
movl %r14d, %esi
movsbq -0x1(%rbx,%rsi), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
je 0x4c7f
leal -0x1(%r14), %edx
movb $0x0, (%rcx)
decq %rcx
cmpl $0x2, %r14d
movl %edx, %r14d
jg 0x4c53
movl $0x1, %r14d
movb (%rbx), %cl
testb %cl, %cl
je 0x4ca5
movq (%rax), %rax
movq %rbx, %rsi
movsbq %cl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x4ca8
decl %r14d
movb 0x1(%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x4c8b
jmp 0x4ca8
movq %rbx, %rsi
incl %r14d
movslq %r14d, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11e0