LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6478
jmp 0x65b2
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6497
jmp 0x65b2
callq 0x1250
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x64e6
callq 0x1250
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x64e6
jmp 0x65b2
jmp 0x64e8
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jle 0x6526
callq 0x1250
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x652f
jmp 0x6545
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x64e8
jmp 0x6547
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
je 0x657c
callq 0x1250
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x6585
jmp 0x659c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6547
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x11a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/string_util.c
// Function: print_tokens
void
print_tokens(unsigned int index){
    
    unsigned int i = 0;
    for ( ; i < index; i++)
    {
        if(tokens[i] == NULL)
            break;

        printf("%s ", tokens[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x6618
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xe11a(%rip), %rax      # 0x14700
cmpq $0x0, (%rax,%rcx,8)
jne 0x65ef
jmp 0x6618
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xe105(%rip), %rax      # 0x14700
movq (%rax,%rcx,8), %rsi
leaq 0x4a81(%rip), %rdi      # 0xb087
movb $0x0, %al
callq 0x10b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x65d2
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/string_util.c
// Function: grep
int
grep (char string[], int string_size, char pattern[]) {

    int rc = 0;
    char *token;

    if (!string_size) return 0;
    
    char *temp_buff = (char *)calloc(1, string_size);
    
    memcpy(temp_buff, string, string_size);
    memset (string, 0, string_size);

    token = strtok(temp_buff, "\n");

    while (token) {

        if (pattern_match(token, strlen(token), pattern)) {

            rc += sprintf(string + rc, "%s\n", token);
        }
        token = strtok(NULL, "\n");
    }
    free(temp_buff);
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x686c
movl $0x0, -0x4(%rbp)
jmp 0x6927
movslq -0x14(%rbp), %rsi
movl $0x1, %edi
callq 0x1100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1150
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x10d0
movq -0x38(%rbp), %rdi
leaq 0x4f74(%rip), %rsi      # 0xb81d
callq 0x11c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6918
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1090
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x67f0
testb $0x1, %al
jne 0x68df
jmp 0x6902
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x30(%rbp), %rdx
leaq 0x41c1(%rip), %rsi      # 0xaab6
movb $0x0, %al
callq 0x1200
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x4f10(%rip), %rsi      # 0xb81d
callq 0x11c0
movq %rax, -0x30(%rbp)
jmp 0x68b2
movq -0x38(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/string_util.c
// Function: string_fetch_integer
uint64_t
string_fetch_integer(char *string, int string_size, int index) {

    int count = 0;
    char *token;

    if (!string_size) return 0;

    char *temp_buff = (char *)calloc(1, string_size);
    memcpy(temp_buff, string, string_size);
    
    token = strtok(temp_buff, " ");

    while (token) {

        if (!is_number(token)) {
            token = strtok(NULL, " ");
            continue;
        }

        count++;
        if (index == count) {
            free(temp_buff);
            return atoi(token);
        }
        
        token = strtok(NULL, " ");
    }
    free(temp_buff);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x695c
movq $0x0, -0x8(%rbp)
jmp 0x6a0f
movslq -0x14(%rbp), %rsi
movl $0x1, %edi
callq 0x1100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1150
movq -0x30(%rbp), %rdi
leaq 0x408f(%rip), %rsi      # 0xaa19
callq 0x11c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x69fe
movq -0x28(%rbp), %rdi
callq 0x6a20
testb $0x1, %al
jne 0x69bd
xorl %eax, %eax
movl %eax, %edi
leaq 0x4067(%rip), %rsi      # 0xaa19
callq 0x11c0
movq %rax, -0x28(%rbp)
jmp 0x6993
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x69e8
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x11d0
cltq
movq %rax, -0x8(%rbp)
jmp 0x6a0f
xorl %eax, %eax
movl %eax, %edi
leaq 0x4026(%rip), %rsi      # 0xaa19
callq 0x11c0
movq %rax, -0x28(%rbp)
jmp 0x6993
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/string_util.c
// Function: is_number
static bool
is_number (char *string) {

    int i = 0;
    while (string[i] != '\0') {

        if (string[i] == '0' || 
             string[i] == '1' ||
             string[i] == '2' ||
             string[i] == '3' ||
             string[i] == '4' ||
             string[i] == '5' ||
             string[i] == '6' ||
             string[i] == '7' ||
             string[i] == '8' ||
             string[i] == '9' ) {

                i++;
                continue;
             }
             else {
                 return false;
             }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6b0a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x32, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x33, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x34, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x35, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x36, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x37, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x38, %eax
je 0x6af6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jne 0x6b04
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6a2f
movb $0x0, -0x1(%rbp)
jmp 0x6b0e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: boolean_validation_handler
CLI_VAL_RC
boolean_validation_handler(leaf_t *leaf, char *value_passed){

    if((strncmp(value_passed, "true", strlen("true")) == 0) || 
            (strncmp(value_passed, "false", strlen("false")) ==0))
        return VALIDATION_SUCCESS;

    return VALIDATION_FAILED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4500(%rip), %rsi      # 0xb08b
movl $0x4, %edx
callq 0x1060
cmpl $0x0, %eax
je 0x6bb4
movq -0x18(%rbp), %rdi
leaq 0x44eb(%rip), %rsi      # 0xb090
movl $0x5, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x6bbd
movl $0x0, -0x4(%rbp)
jmp 0x6bc4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: enable_disable_validation_handler
int
enable_disable_validation_handler(char *value_passed){

     if((strncmp(value_passed, "enable", strlen("enable")) == 0) || 
            (strncmp(value_passed, "disable", strlen("disable")) ==0))
        return VALIDATION_SUCCESS;

    return VALIDATION_FAILED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x394d(%rip), %rsi      # 0xa534
movl $0x6, %edx
callq 0x1060
cmpl $0x0, %eax
je 0x6c10
movq -0x10(%rbp), %rdi
leaq 0x3943(%rip), %rsi      # 0xa544
movl $0x7, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x6c19
movl $0x0, -0x4(%rbp)
jmp 0x6c20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: config_console_name_handler
int
config_console_name_handler(param_t *param, ser_buff_t *b, op_mode enable_or_disable){

    tlv_struct_t *tlv = NULL;

    TLV_LOOP_BEGIN(b, tlv){
        if(enable_or_disable == CONFIG_ENABLE)
            set_device_name(tlv->value);
        else{
            if(strncmp(tlv->value, console_name, strlen(tlv->value)) == 0)
                set_device_name(DEFAULT_DEVICE_NAME);
            else
                printf("Error : Incorrect device name\n");
        }
    }TLV_LOOP_END;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c54
jmp 0x6c73
leaq 0x3799(%rip), %rdi      # 0xa3f4
leaq 0x4434(%rip), %rsi      # 0xb096
movl $0x8d, %edx
leaq 0x4431(%rip), %rcx      # 0xb09f
callq 0x10c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5520
cltq
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x6d2e
cmpl $0x1, -0x14(%rbp)
jne 0x6cc3
movq -0x20(%rbp), %rdi
addq $0x24, %rdi
callq 0x3110
jmp 0x6d12
movq -0x20(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x24, %rdi
callq 0x1090
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xc0f6(%rip), %rsi      # 0x12de0
callq 0x1060
cmpl $0x0, %eax
jne 0x6d02
leaq 0x3774(%rip), %rdi      # 0xa46f
callq 0x3110
jmp 0x6d10
leaq 0x43d8(%rip), %rdi      # 0xb0e1
movb $0x0, %al
callq 0x10b0
jmp 0x6d12
jmp 0x6d14
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x64, %rax
movq %rax, -0x20(%rbp)
jmp 0x6c9d
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: repeat_last_command
int
repeat_last_command(param_t *param, ser_buff_t *b, op_mode enable_or_disable){
    static char new_line_consume[2];
    char *last_cmd = get_last_command();
    printf("prev : %s", last_cmd);
    scanf("%c", new_line_consume);;
    parse_input_cmd(last_cmd, strlen(last_cmd), NULL);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, %al
callq 0x3f10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x4397(%rip), %rdi      # 0xb100
movb $0x0, %al
callq 0x10b0
leaq 0x4393(%rip), %rdi      # 0xb10a
leaq 0xe232(%rip), %rsi      # 0x14fb0
movb $0x0, %al
callq 0x11e0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1090
movq -0x28(%rbp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x41f0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: mode_enter_callback
int
mode_enter_callback(param_t *param, ser_buff_t *b, op_mode enable_or_disable){
 
    if(param == libcli_get_root()){
        printf(ANSI_COLOR_YELLOW "Info : Mode not supported at root level\n" ANSI_COLOR_RESET);
        return 0;   
    }
    set_cmd_tree_cursor(param);
    build_mode_console_name(param);
    
    if(IS_APPLICATION_CALLBACK_HANDLER_REGISTERED(param))
        INVOKE_APPLICATION_CALLBACK_HANDLER(param, b, enable_or_disable);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1d80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x6df3
leaq 0x432a(%rip), %rdi      # 0xb10d
movb $0x0, %al
callq 0x10b0
movl $0x0, -0x4(%rbp)
jmp 0x6e2c
movq -0x10(%rbp), %rdi
callq 0x1fd0
movq -0x10(%rbp), %rdi
callq 0x3850
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6e25
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: display_cmd_expansion_callback
int
display_cmd_expansion_callback(param_t *param, ser_buff_t *b, op_mode enable_or_disable){

    re_init_tokens(MAX_CMD_TREE_DEPTH);
    unsigned int index = 0;

    dump_all_commands(param, index);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x10, %edi
callq 0x6170
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7010
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: dump_all_commands
static void
dump_all_commands(param_t *root, unsigned int index){

        if(!root)
            return;

        if(IS_PARAM_NO_CMD(root))
            return;

        if(IS_PARAM_CMD(root)){
            untokenize(index);
            tokenize(GET_CMD_NAME(root), strlen(GET_CMD_NAME(root)), index);
        }
        else if(IS_PARAM_LEAF(root)){
            untokenize(index);
            memset(temp, 0, sizeof(temp));
            sprintf(temp, "<%s>", GET_LEAF_ID(root));
            tokenize(temp, strlen(GET_LEAF_ID(root)) + 2, index);
        }

        unsigned int i = CHILDREN_START_INDEX;

        for( ; i <= CHILDREN_END_INDEX; i++)
            dump_all_commands(root->options[i], index+1);
        
        if(IS_APPLICATION_CALLBACK_HANDLER_REGISTERED(root)){
            print_tokens(index + 1);
            printf("\n");
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x702b
jmp 0x7133
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x7039
jmp 0x7133
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x7073
movl -0xc(%rbp), %edi
callq 0x6220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1090
movq -0x18(%rbp), %rdi
movl %eax, %esi
movl -0xc(%rbp), %edx
callq 0x61c0
jmp 0x70e0
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x70de
movl -0xc(%rbp), %edi
callq 0x6220
leaq 0xdef5(%rip), %rdi      # 0x14f80
xorl %esi, %esi
movl $0x22, %edx
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x50, %rdx
leaq 0xded6(%rip), %rdi      # 0x14f80
leaq 0x4640(%rip), %rsi      # 0xb6f1
movb $0x0, %al
callq 0x1200
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x50, %rdi
callq 0x1090
addq $0x2, %rax
movl %eax, %esi
movl -0xc(%rbp), %edx
leaq 0xdea7(%rip), %rdi      # 0x14f80
callq 0x61c0
jmp 0x70e0
movl $0x3, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
ja 0x710f
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movq 0x60(%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x7010
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x70e7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7133
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x65c0
leaq 0x46f1(%rip), %rdi      # 0xb81d
movb $0x0, %al
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: record_command
void
record_command(char *hist_file, char *cons_input_buffer, unsigned int cmd_len){

    assert(hist_file || cons_input_buffer || !cmd_len);
    
    static unsigned int cmd_counter = 0;
    
    if(cmd_counter == MAX_SAVED_CMDS){
        return;
    }
    FILE *f = fopen(CMD_HIST_RECORD_FILE, "a");
    fwrite(cons_input_buffer, cmd_len, 1, f);
    fwrite("\n", 1, 1, f);
    cmd_counter++;
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7387
cmpq $0x0, -0x10(%rbp)
jne 0x7387
cmpl $0x0, -0x14(%rbp)
jne 0x7389
jmp 0x73a8
leaq 0x3e94(%rip), %rdi      # 0xb224
leaq 0x3cff(%rip), %rsi      # 0xb096
movl $0x11e, %edx            # imm = 0x11E
leaq 0x3eac(%rip), %rcx      # 0xb24f
callq 0x10c0
cmpl $0x1e, 0xe011(%rip)     # 0x153c0
jne 0x73b3
jmp 0x7411
leaq 0x37e7(%rip), %rdi      # 0xaba1
leaq 0x3213(%rip), %rsi      # 0xa5d4
callq 0x11b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x1220
movq -0x20(%rbp), %rcx
leaq 0x4431(%rip), %rdi      # 0xb81d
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1220
movl 0xdfc1(%rip), %eax      # 0x153c0
addl $0x1, %eax
movl %eax, 0xdfb8(%rip)      # 0x153c0
movq -0x20(%rbp), %rdi
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: config_mode_enter_handler
int
config_mode_enter_handler(param_t *param, ser_buff_t *b, op_mode enable_or_disable){

    set_cmd_tree_cursor(param);
    build_mode_console_name(param);
    mark_checkpoint_serialize_buffer(b);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fd0
movq -0x8(%rbp), %rdi
callq 0x3850
movq -0x10(%rbp), %rdi
callq 0x5630
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: supportsave_handler
int
supportsave_handler(param_t *param, ser_buff_t *b, op_mode enable_or_disable){

    switch(enable_or_disable){
        case CONFIG_ENABLE:
            //signal(SIGTERM, terminate_signal_handler);/*When process is killed*/
            //signal(SIGSEGV, terminate_signal_handler);/*When process access illegal memory*/
            //signal(SIGABRT, terminate_signal_handler);/*when process abort itself*/
            break;
        case CONFIG_DISABLE:
            signal(SIGTERM, SIG_DFL);/*When process is killed*/
            signal(SIGSEGV, SIG_DFL);/*When process access illegal memory*/
            signal(SIGABRT, SIG_DFL);/*when process abort itself*/
            break;
        default:
            assert(0);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x758b
jmp 0x757f
movl -0x18(%rbp), %eax
subl $0x1, %eax
jne 0x75b7
jmp 0x7589
jmp 0x75d6
movl $0xf, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1120
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1120
movl $0x6, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1120
jmp 0x75d6
leaq 0x2dad(%rip), %rdi      # 0xa36b
leaq 0x3ad1(%rip), %rsi      # 0xb096
movl $0x17a, %edx            # imm = 0x17A
leaq 0x3d04(%rip), %rcx      # 0xb2d5
callq 0x10c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: show_resgistered_cmd_handler
int
show_resgistered_cmd_handler(param_t *param, ser_buff_t *b, op_mode enable_or_disable){
    
    /*Implement DFS and dump all complete commands*/
    re_init_tokens(MAX_CMD_TREE_DEPTH);

    param_t *root = libcli_get_root();
    
    unsigned int index = 0;
    dump_all_commands(root, index);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x10, %edi
callq 0x6170
callq 0x1d80
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x7010
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: show_extension_param_handler
int
show_extension_param_handler(param_t *param, ser_buff_t *b, op_mode enable_or_disable){

    tlv_struct_t tlv;
    memset(&tlv, 0, sizeof(tlv_struct_t));

    if(param == libcli_get_show_brief_extension_param()){
        put_value_in_tlv((&tlv), SHOW_EXTENSION_PARAM_BRIEF);
        tlv.leaf_type = INVALID;
        strncpy(tlv.leaf_id, SHOW_EXTENSION_PARAM, strlen("SHOW_EXTENSION_PARAM"));
        collect_tlv(b, &tlv);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x10d0
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x1e10
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jne 0x786a
leaq -0x78(%rbp), %rdi
addq $0x24, %rdi
leaq 0x2c16(%rip), %rsi      # 0xa444
movl $0xa, %edx
callq 0x1050
movl $0x6, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
addq $0x4, %rdi
leaq 0x2be6(%rip), %rsi      # 0xa434
movl $0x14, %edx
callq 0x1050
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x64, %edx
callq 0x5da0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/clistd.c
// Function: grep_pattern_validation
int
grep_pattern_validation(char *value_passed){

    int i = 0;
    while (value_passed[i] != '\0') {
        if (value_passed[i]  == ' ' ) return VALIDATION_FAILED;
        i++;
    }
    return VALIDATION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x78c5
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x78ba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78cc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x788f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: ut_parser_init
void
ut_parser_init ( ) {

    struct mq_attr attr;

    ut_log_file = fopen("CommandParser/ut/utinfra/ut_log_file.txt", "w");
    assert(ut_log_file);

    attr.mq_flags = 0;
    attr.mq_maxmsg = MAX_MESSAGES;
    attr.mq_msgsize = MAX_MSG_SIZE;
    attr.mq_curmsgs = 0;

    if ((UT_PARSER_MSG_Q_FD = mq_open("/ut_parser_msg_q",
                                      O_RDWR | O_CREAT,
                                      QUEUE_PERMISSIONS, &attr)) == -1) {

        printf("UT Parser mq_open failed, errno = %d\n", errno);
        exit(1);
    }

    mq_wait_time.tv_sec = 3;
    mq_wait_time.tv_nsec = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x3dd7(%rip), %rdi      # 0xb6f6
leaq 0x2b94(%rip), %rsi      # 0xa4ba
callq 0x11b0
movq %rax, 0xda9e(%rip)      # 0x153d0
cmpq $0x0, 0xda96(%rip)      # 0x153d0
je 0x793e
jmp 0x795d
leaq 0x3dda(%rip), %rdi      # 0xb71f
leaq 0x3ddf(%rip), %rsi      # 0xb72b
movl $0x30, %edx
leaq 0x3dea(%rip), %rcx      # 0xb742
callq 0x10c0
movq $0x0, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
movq $0x800, -0x30(%rbp)     # imm = 0x800
movq $0x0, -0x28(%rbp)
leaq 0x3dd4(%rip), %rdi      # 0xb758
movl $0x42, %esi
movl $0x1b0, %edx            # imm = 0x1B0
leaq -0x40(%rbp), %rcx
movb $0x0, %al
callq 0x1160
movl %eax, 0xda39(%rip)      # 0x153d8
cmpl $-0x1, %eax
jne 0x79c3
callq 0x1040
movl (%rax), %esi
leaq 0x3db7(%rip), %rdi      # 0xb769
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x1210
movq $0x3, 0xda12(%rip) # 0x153e0
movq $0x0, 0xda0f(%rip) # 0x153e8
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: tc_cleanup_result_list
static void
tc_cleanup_result_list(glthread_t *result_head) {

    glthread_t *curr;
    tc_result_t *res;

    ITERATE_GLTHREAD_BEGIN(result_head, curr) {

        remove_glthread(curr);
        res = glue_to_tc_result(curr);
        free(res);
    }
    ITERATE_GLTHREAD_END(result_head, curr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x90dc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9550
movq -0x10(%rbp), %rdi
callq 0x9410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x90a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: tc_append_result
static void
tc_append_result(glthread_t *head, uint16_t step_no, bool pass, bool match) {

    tc_result_t *res = (tc_result_t *)calloc(1, sizeof(tc_result_t));
    res->step_no = step_no;
    res->pass = pass;
    res->pattern_match = match;
    init_glthread(&res->glue);
    glthread_add_last(head, &res->glue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
andb $0x1, %cl
movb %cl, -0xb(%rbp)
andb $0x1, %al
movb %al, -0xc(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x1100
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb -0xb(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x2(%rax)
movb -0xc(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x9430
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x9660
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: set_ut_debug_flag
static void
set_ut_debug_flag(char * ut_enable_flag) {

    if (strncmp(ut_enable_flag, "enable", strlen("enable")) == 0)
        ut_parser_debug = true;
    else
        ut_parser_debug = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11ed(%rip), %rsi      # 0xa534
movl $0x6, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x935f
movb $0x1, 0xc0ac(%rip)      # 0x15409
jmp 0x9366
movb $0x0, 0xc0a3(%rip)      # 0x15409
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: cli_out
void
cli_out(unsigned char *buff, size_t buff_size) {

    if (!TC_RUNNING) {
        printf("%s", buff);
    }
    else {
        assert(buff_size < UT_PARSER_BUFF_MAX_SIZE);
         if (mq_send(UT_PARSER_MSG_Q_FD, (char *)buff , (buff_size + 1), 0) == -1 ) {
            printf ("mq_send failed on FD %d, errno = %d\n", UT_PARSER_MSG_Q_FD, errno);
         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0xc081(%rip)      # 0x15408
jne 0x939d
movq -0x8(%rbp), %rsi
leaq 0x1e41(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
jmp 0x9409
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
jae 0x93a9
jmp 0x93c8
leaq 0x2752(%rip), %rdi      # 0xbb02
leaq 0x2374(%rip), %rsi      # 0xb72b
movl $0x227, %edx            # imm = 0x227
leaq 0x2763(%rip), %rcx      # 0xbb26
callq 0x10c0
movl 0xc00a(%rip), %edi      # 0x153d8
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
xorl %ecx, %ecx
callq 0x10e0
cmpl $-0x1, %eax
jne 0x9407
movl 0xbfec(%rip), %eax      # 0x153d8
movl %eax, -0x14(%rbp)
callq 0x1040
movl -0x14(%rbp), %esi
movl (%rax), %edx
leaq 0x274c(%rip), %rdi      # 0xbb4c
movb $0x0, %al
callq 0x10b0
jmp 0x9409
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: glthread_add_next
void
glthread_add_next(glthread_t *curr_glthread, glthread_t *new_glthread){

    if(!curr_glthread->right){
        curr_glthread->right = new_glthread;
        new_glthread->left = curr_glthread;
        return;
    }

    glthread_t *temp = curr_glthread->right;
    curr_glthread->right = new_glthread;
    new_glthread->left = curr_glthread;
    new_glthread->right = temp;
    temp->left = new_glthread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9490
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x94ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: glthread_add_before
void
glthread_add_before(glthread_t *curr_glthread, glthread_t *new_glthread){
    
    if(!curr_glthread->left){
        new_glthread->left = NULL;
        new_glthread->right = curr_glthread;
        curr_glthread->left = new_glthread;
        return;
    }
    
    glthread_t *temp = curr_glthread->left;
    temp->right = new_glthread;
    new_glthread->left = temp;
    new_glthread->right = curr_glthread;
    curr_glthread->left = new_glthread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x950a
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9543
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: remove_glthread
void
remove_glthread(glthread_t *curr_glthread){
    
    if(!curr_glthread->left){
        if(curr_glthread->right){
            curr_glthread->right->left = NULL;
            curr_glthread->right = 0;
            return;
        }
        return;
    }
    if(!curr_glthread->right){
        curr_glthread->left->right = NULL;
        curr_glthread->left = NULL;
        return;
    }

    curr_glthread->left->right = curr_glthread->right;
    curr_glthread->right->left = curr_glthread->left;
    curr_glthread->left = 0;
    curr_glthread->right = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x958c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x958a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x95ef
jmp 0x95ef
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x95b3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x95ef
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: delete_glthread_list
void
delete_glthread_list(glthread_t *glthread_head){

    glthread_t *glthreadptr = NULL;
               
    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
        remove_glthread(glthreadptr);
    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x964e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9550
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9628
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: glthread_add_last
void
glthread_add_last(glthread_t *glthread_head, glthread_t *new_glthread){

    glthread_t *glthreadptr = NULL,
               *prevglthreadptr = NULL;
    
    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
        prevglthreadptr = glthreadptr;
    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
  
    if(prevglthreadptr) 
        glthread_add_next(prevglthreadptr, new_glthread); 
    else
        glthread_add_next(glthread_head, new_glthread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x96b9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9694
cmpq $0x0, -0x20(%rbp)
je 0x96cf
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9460
jmp 0x96dc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: get_glthread_list_count
unsigned int
get_glthread_list_count(glthread_t *glthread_head){

    unsigned int count = 0;
    glthread_t *glthreadptr = NULL;

    ITERATE_GLTHREAD_BEGIN(glthread_head, glthreadptr){
        count++;
    } ITERATE_GLTHREAD_END(glthread_head, glthreadptr);
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9741
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x971b
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/gluethread/glthread.c
// Function: dequeue_glthread_first
glthread_t *
dequeue_glthread_first(glthread_t *base_glthread){

    glthread_t *temp;
    if(!base_glthread->right)
        return NULL;
    temp = base_glthread->right;
    remove_glthread(temp);
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x98e1
movq $0x0, -0x8(%rbp)
jmp 0x98fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9550
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sock_util/main.c
// Function: main
int
main(int argc, char * argv[])
{

	WARNP_INIT;
	(void)argc; /* UNUSED */

	if (check_ensure_port())
		goto err0;

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x23ec
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cf0
jmp 0x23ee
callq 0x2410
cmpl $0x0, %eax
je 0x23fa
jmp 0x2401
xorl %edi, %edi
callq 0x2250
movl $0x1, %edi
callq 0x2250
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sock_util/main.c
// Function: check_ensure_port
static int
check_ensure_port(void)
{
	size_t i;
	const char * in;
	const char * expected;
	char * out;

	for (i = 0; i < sizeof(tests_port) / sizeof(tests_port[0]); i++) {
		/* Get test data. */
		in = tests_port[i].input;
		expected = tests_port[i].output;

		/* Run the function and check its output. */
		out = sock_addr_ensure_port(in);
		if (strcmp(out, expected) != 0) {
			warn0("Failed; sock_addr_ensure_port(\"%s\") "
			    "expected \"%s\", got \"%s\"", in, expected, out);
			goto err1;
		}

		/* Clean up. */
		free(out);
	}

	/* Success! */
	return (0);

err1:
	free(out);

	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x10(%rbp)
cmpq $0x9, -0x10(%rbp)
jae 0x24c0
movq -0x10(%rbp), %rcx
leaq 0x4d3a(%rip), %rax      # 0x7170
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x4d21(%rip), %rax      # 0x7170
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
je 0x24a6
jmp 0x247f
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x2b72(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x3000
callq 0x2090
movl $0x0, (%rax)
jmp 0x24c9
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2420
movl $0x0, -0x4(%rbp)
jmp 0x24d9
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vusec[P]fpvi-scsb/leakers/mo/leak.c
// Function: segfault_handler
static void segfault_handler(int signum) {
    (void)signum;
    unblock_signal(SIGSEGV);
    sigsegvs++;
    longjmp(buf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xb, %edi
callq 0x4017e0
movl 0x2e2d(%rip), %eax      # 0x4045e8
addl $0x1, %eax
movl %eax, 0x2e24(%rip)      # 0x4045e8
leaq 0x2d55(%rip), %rdi      # 0x404520
movl $0x1, %esi
callq 0x401140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: analyze_url
int analyze_url(char* url,char* host,int port,char** page){
	//url should be like 'http://host:port/page'
	//only page need to be returned
	int hostsize=strlen(host);
	if(strlen(url) < 12+hostsize) return -1;

	url[6]='\0';
	url[7+hostsize]='\0';
	url[12+hostsize]='\0';
	//now url should be like 'http:/\0host\0port\0page'
	if(strcmp(url,"http:/")) return -1;
	//if(strcmp(url+7,host)) return -1;
	char *cport=myitoa(port);
	if(strcmp(url+8+hostsize,cport)) {free(cport);return -1;}
	(*page) = malloc((strlen(url+13+hostsize)+2)*sizeof(char));
	strcpy((*page),"/");
	strcat((*page),url+13+hostsize);
	//printf("%s\n",(*page));
	free(cport);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movl -0x2c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x25d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26c8
movq -0x10(%rbp), %rax
movb $0x0, 0x6(%rax)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
leaq 0x29f9(%rip), %rsi      # 0x5004
callq 0x2180
cmpl $0x0, %eax
je 0x2621
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26c8
movl -0x1c(%rbp), %edi
callq 0x24f0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x2180
cmpl $0x0, %eax
je 0x265c
movq -0x38(%rbp), %rdi
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26c8
movq -0x10(%rbp), %rdi
addq $0xd, %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x2b37(%rip), %rsi      # 0x51cf
callq 0x2070
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xd, %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
callq 0x2310
movq -0x38(%rbp), %rdi
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: create_request
char* create_request(char* page, char* hostname, int port){
	char *req;
	char* chport=myitoa(port);
	int size=47+strlen(page)+strlen(hostname)+strlen(chport);
	req = malloc(size*sizeof(char));
	strcpy(req,"GET ");
	strcat(req,page);
	strcat(req," HTTP/1.1\r\nHost: ");
	strcat(req,hostname);
	strcat(req,":");
	strcat(req,chport);
	strcat(req,"\r\nConnection: Closed\r\n\r\n");
	free(chport);
	return req;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x24f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
addq $0x2f, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x28b2(%rip), %rsi      # 0x500b
callq 0x2070
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2310
movq -0x20(%rbp), %rdi
leaq 0x289a(%rip), %rsi      # 0x5010
callq 0x2310
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
movq -0x20(%rbp), %rdi
leaq 0x288f(%rip), %rsi      # 0x5022
callq 0x2310
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2310
movq -0x20(%rbp), %rdi
leaq 0x2874(%rip), %rsi      # 0x5024
callq 0x2310
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: read_request
char* read_request(int fd,int size){
	int n;
	int counter=1;
	int flag;
	char *tempbuf=NULL;
	char *buf=NULL;
	while(1){
		flag=0;
		tempbuf=calloc((size+1),sizeof(char));
		if((n=read(fd,tempbuf,size)) <= 0) break;
		if(counter == 1) flag=1;
		counter+=n;
		if(flag){
			buf = malloc((counter+1)*sizeof(char));
			strcpy(buf,tempbuf);//first time copy
		}
		else{
			buf = realloc(buf,(counter+1)*sizeof(char));
			strcat(buf,tempbuf);//then cat
		}
		free(tempbuf);
	}
	free(tempbuf);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x8(%rbp), %rdx
callq 0x2150
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jg 0x282d
jmp 0x28a3
cmpl $0x1, -0x10(%rbp)
jne 0x283a
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x286e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2070
jmp 0x2895
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
callq 0x2240
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2310
movq -0x20(%rbp), %rdi
callq 0x2030
jmp 0x27f5
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: read_command
int read_command(int fd,char **buf,int size){
	char c;
	int n;
	int counter=0;
	while(1){
		if((n=read(fd,&c,1)) < 0) return n;
		if(!n)
			break;
		if(counter == size){//then realloc 
			size *=2;
			(*buf) = realloc((*buf),size*sizeof(char));
		}
		if(c == '\0' || c == EOF || c == '\n' || c == 13){//13 is the carriege return
			read(fd,&c,1);//read the '\n'
			(*buf)[counter] = '\0';
			break;
		}
		else (*buf)[counter++] = c;
	}
	return counter+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x8(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x28fd
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29a5
cmpl $0x0, -0x1c(%rbp)
jne 0x2908
jmp 0x299c
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x2936
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x0, %rsi
callq 0x2240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
je 0x295a
movsbl -0x15(%rbp), %eax
cmpl $-0x1, %eax
je 0x295a
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
je 0x295a
movsbl -0x15(%rbp), %eax
cmpl $0xd, %eax
jne 0x297c
movl -0x8(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x2150
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x299c
movb -0x15(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x28d9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop