LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: set_cmd_val
int set_cmd_val(char* str, int type, cmd_t** cmd)
{
    int     len = 0;

    char*   tmp = NULL,
        *   bak = str;

    while ( *str != ';'     &&
            *str != '|'     &&
            *str != '&'     &&
            *str != '<'     &&
            *str != '>'     &&
            *str != '\0'    &&
            *str != '\n') {
        str++;
        len++;
    }
    if ((*str == '>' || *str == '<')
            && isdigit(*(str - 1)))
        len--;

    str = bak;
    if ((tmp = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -1;

    memcpy(tmp, str, len);
    tmp[len] = '\0';
    trim(tmp);

    (*cmd)->args = str_to_args(tmp);
    (*cmd)->type = type;
    free(tmp);

    return 0;
}

// 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)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3b, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x7c, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x26, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3c, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3e, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x2af0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2af9
jmp 0x2b13
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a7a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0x2b2b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x2b55
callq 0x21c0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2b55
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2b82
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2bdb
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x2410
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
callq 0x2930
movq -0x30(%rbp), %rdi
callq 0x2bf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x2180
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/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: add_cmdline_t
cmd_t* add_cmdline_t(cmd_t** cmd)
{
    if (((*cmd)->next = (cmd_t*)
                malloc(sizeof(cmd_t))) == NULL)
        return NULL;

    (*cmd)->next->prev = *cmd;
    *cmd = (*cmd)->next;
    (*cmd)->next = NULL;
    (*cmd)->io = NULL;

    return *cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x28, %edi
callq 0x20e0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x2fe1
movq $0x0, -0x8(%rbp)
jmp 0x3032
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: release_cmd_t
void release_cmd_t(cmd_t* cmd)
{
    int     i   = 0;

    cmd_t*  tmp = NULL;

    while (cmd != NULL) {
        tmp = cmd->next;
        if (cmd->io != NULL) {
            if (cmd->io->io_name != NULL)
                free(cmd->io->io_name);
            free(cmd->io);
        }
        i = 0;
        while (cmd->args[i] != NULL) {
            free(cmd->args[i]);
            i++;
        }
        free(cmd->args);
        free(cmd);
        cmd = tmp;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3567
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x350a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x34fd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3544
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3511
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x34bb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: check_file_stat
int check_file_stat(cmd_t* cmd, int is_redirect, mode_t chk)
{
    char*   path    = NULL;

    struct stat st;

    if (is_redirect == 1)
        path = cmd->io->io_name;
    else
        path = cmd->args[0];

    if (stat(path, &st) < 0) {
        switch (errno) {
            case    ENOENT:
                if (is_redirect == 1)
                    return 0;

                fprintf(stderr, "no such file or directory: %s\n",
                        path);

                return -1;
            case    EACCES:
                fprintf(stderr, "permission denied: %s\n",
                        path);

                return -2;
        }
    }

    if ((st.st_mode & S_IFMT) == S_IFDIR) {
        fprintf(stderr, "permission denied: %s\n",
                path);

        return -3;
    }
    if ((st.st_mode & chk) == 0) {
        fprintf(stderr, "permission denied: %s\n",
                path);

        return -4;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3795
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x37a4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2400
cmpl $0x0, %eax
jge 0x383f
callq 0x2350
movl (%rax), %eax
movl %eax, -0xb4(%rbp)
subl $0x2, %eax
je 0x37de
jmp 0x37d1
movl -0xb4(%rbp), %eax
subl $0xd, %eax
je 0x3818
jmp 0x383d
cmpl $0x1, -0x14(%rbp)
jne 0x37f0
movl $0x0, -0x4(%rbp)
jmp 0x38b0
movq 0x137f1(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe81c(%rip), %rsi      # 0x12021
movb $0x0, %al
callq 0x23f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38b0
movq 0x137c9(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe813(%rip), %rsi      # 0x12040
movb $0x0, %al
callq 0x23f0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x38b0
jmp 0x383f
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x3876
movq 0x13790(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe7da(%rip), %rsi      # 0x12040
movb $0x0, %al
callq 0x23f0
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x38b0
movl -0x98(%rbp), %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
jne 0x38a9
movq 0x1375d(%rip), %rax     # 0x16fe8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe7a7(%rip), %rsi      # 0x12040
movb $0x0, %al
callq 0x23f0
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x38b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: redirect
void redirect(int oldfd, int newfd)
{
    if (oldfd != newfd) {
        if (dup2(oldfd, newfd) == -1)
            close(oldfd);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x4110
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2040
cmpl $-0x1, %eax
jne 0x410e
movl -0x4(%rbp), %edi
callq 0x2060
jmp 0x4110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: mwait
int mwait(void)
{
    int     status  = 0;

    pid_t   pid     = 0;

    while (1) {
        if ((pid = wait(&status)) == -1) {
            if (errno == ECHILD)
                break;
            else if (errno == EINTR)
                continue;
        }
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x2070
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
jne 0x4163
callq 0x2350
cmpl $0xa, (%rax)
jne 0x4153
jmp 0x4165
callq 0x2350
cmpl $0x4, (%rax)
jne 0x415f
jmp 0x4136
jmp 0x4161
jmp 0x4163
jmp 0x4136
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: init_shash
int init_shash(SHASH** shash)
{
    int     status  = 0;

    SHASH*  shs     = NULL;

    if ((shs = (SHASH*)
                malloc(sizeof(SHASH))) == NULL) {
        status = -1; goto ERR;
    } else {
        shs->elemc      = 0;
        shs->put        = put_shash;
        shs->get        = get_shash;
        shs->getv       = getv_shash;
        shs->keys       = keys_shash;
        shs->values     = values_shash;
        shs->is_empty   = is_empty_shash;
        shs->size       = size_shash;
        shs->exists     = key_exists_shash;
        shs->remove     = remove_shash;
        shs->clear      = clear_shash;
        shs->release    = release_shash;
        shs->elem_size  = DEFAULT_ELEM_SIZE;
    }
    if (allocate_elem(&shs) < 0) {
        status = -2; goto ERR;
    }
    *shash = shs;

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            if (shs != NULL) {
                free(shs);
                shs = NULL;
            }
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x70, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4e9b
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x4f81
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
leaq 0x120(%rip), %rcx       # 0x4fd0
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x321(%rip), %rcx       # 0x51e0
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x372(%rip), %rcx       # 0x5240
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq 0x413(%rip), %rcx       # 0x52f0
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
leaq 0x4c4(%rip), %rcx       # 0x53b0
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
leaq 0x575(%rip), %rcx       # 0x5470
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
leaq 0x586(%rip), %rcx       # 0x5490
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
leaq 0x587(%rip), %rcx       # 0x54a0
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
leaq 0x648(%rip), %rcx       # 0x5570
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rax
leaq 0x729(%rip), %rcx       # 0x5660
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
leaq 0x86a(%rip), %rcx       # 0x57b0
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
movq $0x20, 0x68(%rax)
leaq -0x20(%rbp), %rdi
callq 0x5970
cmpl $0x0, %eax
jge 0x4f6d
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
jmp 0x4f81
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4fba
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $-0x2, %eax
je 0x4f9a
jmp 0x4f8e
movl -0x24(%rbp), %eax
subl $-0x1, %eax
jne 0x4fb4
jmp 0x4f98
jmp 0x4fb4
cmpq $0x0, -0x20(%rbp)
je 0x4fb2
movq -0x20(%rbp), %rdi
callq 0x2180
movq $0x0, -0x20(%rbp)
jmp 0x4fb4
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: get_shash
static
char* get_shash(SHASH* shash, const char* key)
{
    int     pos     = 0;

    if ((pos = shash->exists(shash, key)) < 0)
        return NULL;

    return *(*(shash->elem + pos) + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x521b
movq $0x0, -0x8(%rbp)
jmp 0x5233
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: getv_shash
static
int getv_shash(SHASH* shash, const char* key, char** ptr)
{
    size_t  len     = 0;

    char*   value   = NULL;

    if ((value = shash->get(shash, key)) == NULL)
        return -1;

    len = strlen(value);
    if ((*ptr = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -2;
    memcpy(*ptr, value, len);
    *(*(ptr) + len) = '\0';

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5289
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52e7
movq -0x30(%rbp), %rdi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x52bd
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x52e7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2410
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: keys_shash
static
char** keys_shash(SHASH* shash)
{
    int     i       = 0;

    char**  keys    = NULL;

    if ((keys = (char**)
                malloc(sizeof(char*) * shash->size(shash))) != NULL) {
        while (i < shash->size(shash) &&
                (*(keys + i) = *(*(shash->elem + i))))
            i++;
        *(keys + i) = NULL;
    }

    return keys;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x53a0
jmp 0x5331
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0x20(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jge 0x537c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x5385
jmp 0x5390
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5331
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: values_shash
static
char** values_shash(SHASH* shash)
{
    int     i       = 0;

    char**  values  = NULL;

    if ((values = (char**)
                malloc(sizeof(char*) * shash->size(shash))) != NULL) {
        while (i < shash->size(shash) &&
                (*(values + i) = *(*(shash->elem + i) + 1)))
            i++;
        *(values + i) = NULL;
    }

    return values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5461
jmp 0x53f1
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0x20(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jge 0x543d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x5446
jmp 0x5451
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x53f1
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: key_exists_shash
static
int key_exists_shash(SHASH* shash, const char* key)
{
    int     i       = 0,
            j       = 0;

    j = shash->elemc - 1;
    while (i < shash->elemc && i <= j) {
        if (strcmp_lite(*(*(shash->elem + i)), key) == 0)
            return i;
        if (strcmp_lite(*(*(shash->elem + j)), key) == 0)
            return j;
        i++;
        j--;
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x21(%rbp)
jge 0x54e6
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x54ef
jmp 0x5558
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6010
cmpl $0x0, %eax
jne 0x5518
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x555f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6010
cmpl $0x0, %eax
jne 0x5541
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x555f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x54ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: remove_shash
static
void remove_shash(SHASH** shash, const char* key)
{
    int     pos     = 0;

    if ((pos = (*shash)->exists(*shash, key)) < 0)
        return;

    remove_key_elem(*shash, pos);
    remove_value_elem(*shash, pos);
    while (pos < (*shash)->elemc &&
            (*((*shash)->elem + pos) = *((*shash)->elem + (pos + 1))))
        pos++;
    (*shash)->elemc--;
    *((*shash)->elem + (*shash)->elemc) = NULL;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x55ac
jmp 0x5651
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x5fb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x6100
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x15(%rbp)
jge 0x5612
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x561b
jmp 0x5626
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq (%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: clear_shash
static
void clear_shash(SHASH** shash)
{
    int     i       = 0,
            j       = 0;

    j = (*shash)->elemc - 1;
    while (i < (*shash)->elemc && i <= j) {
        if (*((*shash)->elem + i) != NULL) {
            remove_key_elem(*shash, i);
            remove_value_elem(*shash, i);
            free(*((*shash)->elem + i));
            *((*shash)->elem + i) = NULL;
        }
        if (*((*shash)->elem + j) != NULL) {
            remove_key_elem(*shash, j);
            remove_value_elem(*shash, j);
            free(*((*shash)->elem + j));
            *((*shash)->elem + j) = NULL;
        }
        i++;
        j--;
    }
    (*shash)->elemc = 0;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x11(%rbp)
jge 0x56a8
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x56b4
jmp 0x5791
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5717
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x5fb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x577a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x5fb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x6100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5689
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: clone_shash
SHASH* clone_shash(SHASH* shash)
{
    int     i       = 0;

    SHASH*  shs     = NULL;

    if (init_shash(&shs) < 0)
        return NULL;

    while (i < shash->size(shash)) {
        if (shs->put(&shs, *(*(shash->elem + i)), *(*(shash->elem + i) + 1)) < 0)
            goto ERR;
        i++;
    }

    return shs;

ERR:
    shs->release(shs);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4e60
cmpl $0x0, %eax
jge 0x5ba6
movq $0x0, -0x8(%rbp)
jmp 0x5c2c
jmp 0x5ba8
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x5c0c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rdx
leaq -0x20(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x5c01
jmp 0x5c16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5ba8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c2c
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: put_key_elem
static
int put_key_elem(SHASH** shash, const char* key, int pos)
{
    size_t  len     = 0;

    len = strlen(key);
    if ((*(*((*shash)->elem + pos)) = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -1;

    memcpy(*(*((*shash)->elem + pos)), key, len);
    *(*(*((*shash)->elem + pos)) + len) = '\0';

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x5e9e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5ee6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: put_value_elem
static
int put_value_elem(SHASH** shash, const char* value, int pos)
{
    size_t  len     = 0;

    len = strlen(value);
    if ((*(*(((*shash)->elem + pos)) + 1) = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL)
        return -1;

    memcpy(*(*((*shash)->elem + pos) + 1), value, len);
    *(*(*((*shash)->elem + pos) + 1) + len) = '\0';

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x5f4f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f99
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
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/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: remove_key_elem
static
void remove_key_elem(SHASH* shash, int pos)
{
    if (*(*(shash->elem + pos)) != NULL) {
        free(*(*(shash->elem + pos)));
        *(*(shash->elem + pos)) = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
je 0x6004
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: remove_value_elem
static
void remove_value_elem(SHASH* shash, int pos)
{
    if (*(*(shash->elem + pos) + 1) != NULL) {
        free(*(*(shash->elem + pos) + 1));
        *(*(shash->elem + pos) + 1) = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
je 0x6157
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: init_proc
int init_proc(PROC** proc)
{
    PROC*   prc     = NULL;
    
    if ((prc = (PROC*)
                malloc(sizeof(PROC))) == NULL) {
        return -1;
    } else {
        prc->pid        = 0;
        prc->argc       = 0;
        prc->argv       = NULL;
        prc->envp       = NULL;
        prc->set        = set_cmd_proc;
        prc->setv       = set_cmd_argv_proc;
#ifdef  _GNU_SOURCE
        prc->set_env    = set_env_proc;
        prc->unset_env  = unset_env_proc;
        prc->rfork      = rfork_proc;
/* _GNU_SOURCE */
#endif
        prc->fork       = fork_proc;
        prc->wait       = wait_proc;
        prc->exec       = exec_proc;
        prc->ready      = exec_ready_proc;
        prc->kill       = kill_proc;
        prc->release    = release_proc;
        prc->status     = 0;
    }
    *proc = prc;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x78, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x64e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65d3
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
leaq 0xc4(%rip), %rcx        # 0x65e0
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
leaq 0x315(%rip), %rcx       # 0x6840
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x4f6(%rip), %rcx       # 0x6a30
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0x697(%rip), %rcx       # 0x6be0
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
leaq 0x6c8(%rip), %rcx       # 0x6c20
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
leaq 0x709(%rip), %rcx       # 0x6c70
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
leaq 0x72a(%rip), %rcx       # 0x6ca0
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
leaq 0x76b(%rip), %rcx       # 0x6cf0
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
leaq 0x7dc(%rip), %rcx       # 0x6d70
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
leaq 0x80d(%rip), %rcx       # 0x6db0
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
leaq 0x83e(%rip), %rcx       # 0x6df0
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: unset_env_proc
static
void unset_env_proc(PROC** proc)
{
    if ((*proc)->envp != NULL) {
        release_env_proc(*proc);
        (*proc)->envp = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x6c15
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7720
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: exec_proc
static
int exec_proc(PROC* proc)
{
    if (proc->ready(proc) < 0)
        return -1;

    if (proc->envp != NULL)
        return execvpe(*(proc->argv), proc->argv, proc->envp);
    else
        return execvp(*(proc->argv), proc->argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x6d18
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d63
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6d48
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x2110
movl %eax, -0x4(%rbp)
jmp 0x6d63
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x20b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: release_proc
static
void release_proc(PROC* proc)
{
    if (proc != NULL) {
#ifdef  _GNU_SOURCE
        if (proc->envp != NULL) {
            release_env_proc(proc);
        }
/* _GNU_SOURCE */
#endif
        release_argv_proc(proc);
        free(proc);
        proc = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6e31
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6e17
movq -0x8(%rbp), %rdi
callq 0x7720
movq -0x8(%rbp), %rdi
callq 0x75e0
movq -0x8(%rbp), %rdi
callq 0x2180
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: simple_exec
int simple_exec(const char* cmd)
{
    int     status  = 0;

    PROC*   proc    = NULL;

    do {
        if (init_proc(&proc) < 0) {
            status = -1; break;
        }
        if (proc->set(&proc, cmd) < 0) {
            status = -2; break;
        }
        if (proc->ready(proc) < 0) {
            status = -3; break;
        }
        if (proc->exec(proc) < 0) {
            status = -4; break;
        }
    } while (0);

    switch (status) {
        case    -1:
            break;
        case    -2:
        case    -3:
        case    -4:
            proc->release(proc);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x64b0
cmpl $0x0, %eax
jge 0x6e72
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ecc
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x6e92
movl $0xfffffffe, -0xc(%rbp) # imm = 0xFFFFFFFE
jmp 0x6ecc
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x6eae
movl $0xfffffffd, -0xc(%rbp) # imm = 0xFFFFFFFD
jmp 0x6ecc
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jge 0x6eca
movl $0xfffffffc, -0xc(%rbp) # imm = 0xFFFFFFFC
jmp 0x6ecc
jmp 0x6ecc
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addl $0x4, %eax
subl $0x3, %eax
jb 0x6ee8
jmp 0x6edc
movl -0x1c(%rbp), %eax
subl $-0x1, %eax
jne 0x6ef6
jmp 0x6ee6
jmp 0x6ef6
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: add_mproc
static
int add_mproc(MPROC** mproc, PROC* proc)
{
    if ((*mproc)->procs >= MPROC_MAX)
        return -1;

    (*mproc)->proc[(*mproc)->procs] = proc;
    (*mproc)->procs++;
    (*mproc)->proc[(*mproc)->procs] = NULL;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x20, 0x8(%rax)
jl 0x70d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7123
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x8(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: del_mproc
static
int del_mproc(MPROC** mproc, int proc_no)
{
    if ((*mproc)->procs <= 1 ||
            (*mproc)->proc[proc_no] == NULL)
        return -1;

    while (proc_no < (*mproc)->procs &&
            ((*mproc)->proc[proc_no] = (*mproc)->proc[proc_no + 1]))
        proc_no++;
    (*mproc)->procs--;
    (*mproc)->proc[(*mproc)->procs] = NULL;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x8(%rax)
jle 0x715d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7169
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x71fa
jmp 0x716b
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x15(%rbp)
jge 0x71b2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x71bb
jmp 0x71c6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x716b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x8(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: fork_mproc
static
int fork_mproc(MPROC* mproc)
{
    int     proc_no = 0;

    for (proc_no = 0;
            proc_no < mproc->procs &&
            (mproc->proc_no = mproc->proc[proc_no]->fork(&mproc->proc[proc_no])); proc_no++);

    return proc_no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0xd(%rbp)
jge 0x7262
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
callq *%rax
movq -0x8(%rbp), %rcx
movl %eax, 0xc(%rcx)
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x726b
jmp 0x7278
jmp 0x726d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x721a
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: rfork_mproc
static
int rfork_mproc(MPROC* mproc, unsigned long flags)
{
    int     proc_no = 0;

    for (proc_no = 0;
            proc_no < mproc->procs &&
            (mproc->proc_no = mproc->proc[proc_no]->rfork(&mproc->proc[proc_no], flags)); proc_no++);

    return proc_no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x15(%rbp)
jge 0x72fa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rcx
movl %eax, 0xc(%rcx)
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x7303
jmp 0x7310
jmp 0x7305
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x72ae
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: wait_mproc
static
int wait_mproc(MPROC** mproc, int opts)
{
    int     i   = 0;

    while (i < (*mproc)->procs) {
        (*mproc)->proc[i]->wait(&(*mproc)->proc[i], opts);
        i++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x7430
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movslq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movl -0xc(%rbp), %esi
callq *%rax
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x73e6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: killall_mproc
static
int killall_mproc(MPROC* mproc, int sig)
{
    int     i   = 0;

    while (i < mproc->procs) {
        if ((mproc->proc[i]->kill(mproc->proc[i], sig)) < 0)
            return -1;
        i++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x7502
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movl -0x14(%rbp), %esi
callq *%rax
cmpl $0x0, %eax
jge 0x74f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7509
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x74b6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: release_mproc
static
void release_mproc(MPROC* mproc)
{
    int     i   = 0;

    if (mproc != NULL) {
        if (mproc->proc != NULL) {
            while (i < mproc->procs) {
                if (mproc->proc[i] != NULL) {
                    mproc->proc[i]->release(mproc->proc[i]);
                    mproc->proc[i] = NULL;
                    i++;
                }
            }
            free(mproc->proc);
            mproc->proc = NULL;
        }
        free(mproc);
        mproc = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x75d2
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x75c1
jmp 0x754a
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x75aa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x75a8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x754a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2180
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: release_argv_proc
static
void release_argv_proc(PROC* proc)
{
    if (proc->argv != NULL) {
        while (proc->argc >= 0) {
            if (*(proc->argv + proc->argc) != NULL) {
                free(*(proc->argv + proc->argc));
                *(proc->argv + proc->argc) = NULL;
            }
            proc->argc--;
        }
        free(proc->argv);
        proc->argv = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7673
jmp 0x75f9
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x765a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x764b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x75f9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: release_env_proc
static
void release_env_proc(PROC* proc)
{
    size_t  i   = 0;

    if (proc->envp != NULL) {
        while (*(proc->envp + i) != NULL) {
            free(*(proc->envp + i));
            *(proc->envp + i) = NULL;
            i++;
        }
        free(proc->envp);
        proc->envp = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x77a4
jmp 0x7741
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x778b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7741
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)