LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_lisp_comment
void test_regex_lisp_comment(void) {

  mpc_parser_t *re0 = mpc_re(";[^\\n\\r]*");

  PT_ASSERT(regex_test_pass(re0, ";comment", ";comment"));
  PT_ASSERT(regex_test_pass(re0, ";i am the\nman", ";i am the"));

  mpc_delete(re0);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xc845(%rip), %rdi      # 0x11853
callq 0x92b6
movq %rax, %rbx
leaq 0xc840(%rip), %rdx      # 0x1185d
leaq -0x7ea(%rip), %r14      # 0x483a
movq 0x12f9d(%rip), %r15     # 0x17fc8
leaq -0x7e7(%rip), %r12      # 0x484b
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc819(%rip), %rsi      # 0x11866
leaq 0xc305(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x74, %ecx
callq 0x4050
leaq 0xc829(%rip), %rsi      # 0x11893
leaq 0xc830(%rip), %rdx      # 0x118a1
movq %rbx, %rdi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc822(%rip), %rsi      # 0x118ab
movl %eax, %edi
movq %r13, %rdx
movl $0x75, %ecx
callq 0x4050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_newline
void test_regex_newline(void) {

  mpc_parser_t *re0 = mpc_re("[a-z]*");

  PT_ASSERT(regex_test_pass(re0, "hi", "hi"));
  PT_ASSERT(regex_test_pass(re0, "hi\nk", "hi"));
  PT_ASSERT(regex_test_fail(re0, "hi\nk", "hi\nk"));

  mpc_delete(re0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc824(%rip), %rdi      # 0x118df
callq 0x92b6
movq %rax, %rbx
leaq 0xc81c(%rip), %rbp      # 0x118e6
leaq -0x897(%rip), %rcx      # 0x483a
movq 0x12ef0(%rip), %r12     # 0x17fc8
leaq -0x894(%rip), %r13      # 0x484b
movq %rax, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %r12, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xc7ef(%rip), %rsi      # 0x118e9
leaq 0xc258(%rip), %r15      # 0x11359
movl %eax, %edi
movq %r15, %rdx
movl $0x7f, %ecx
callq 0x4050
leaq 0xc7f3(%rip), %r14      # 0x1190a
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
leaq -0x8ed(%rip), %rcx      # 0x483a
movq %r12, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xc7d6(%rip), %rsi      # 0x1190f
movl %eax, %edi
movq %r15, %rdx
movl $0x80, %ecx
callq 0x4050
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
leaq -0x91e(%rip), %rcx      # 0x483a
movq %r12, %r8
movq %r13, %r9
callq 0xa9c0
leaq 0xc7c9(%rip), %rsi      # 0x11933
movl %eax, %edi
movq %r15, %rdx
movl $0x81, %ecx
callq 0x4050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_multiline
void test_regex_multiline(void) {

  mpc_parser_t *re0 = mpc_re_mode("(^[a-z]*$)*", MPC_RE_MULTILINE);

  PT_ASSERT(regex_test_pass(re0, "hello\nhello", "hello\nhello"));
  PT_ASSERT(regex_test_pass(re0, "hello\nhello\n", "hello\nhello\n"));
  PT_ASSERT(regex_test_pass(re0, "\nblah\n\nblah\n", "\nblah\n\nblah\n"));
  PT_ASSERT(regex_test_fail(re0, "45234", "45234"));
  PT_ASSERT(regex_test_fail(re0, "\n45234", "\n45234"));
  PT_ASSERT(regex_test_pass(re0, "\n45234", "\n"));

  mpc_delete(re0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc7b9(%rip), %rdi      # 0x1195a
movl $0x1, %esi
callq 0x92bd
movq %rax, %rbx
leaq 0xc7b1(%rip), %rdx      # 0x11966
leaq -0x982(%rip), %r14      # 0x483a
movq 0x12e05(%rip), %r15     # 0x17fc8
leaq -0x97f(%rip), %r12      # 0x484b
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc78d(%rip), %rsi      # 0x11972
leaq 0xc16d(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x8b, %ecx
callq 0x4050
leaq 0xc7a5(%rip), %rdx      # 0x119a7
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc797(%rip), %rsi      # 0x119b4
movl %eax, %edi
movq %r13, %rdx
movl $0x8c, %ecx
callq 0x4050
leaq 0xc7ba(%rip), %rdx      # 0x119ed
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc7ac(%rip), %rsi      # 0x119fa
movl %eax, %edi
movq %r13, %rdx
movl $0x8d, %ecx
callq 0x4050
leaq 0xc7fb(%rip), %rdx      # 0x11a5f
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa9c0
leaq 0xc7b8(%rip), %rsi      # 0x11a37
movl %eax, %edi
movq %r13, %rdx
movl $0x8e, %ecx
callq 0x4050
leaq 0xc7c9(%rip), %rbp      # 0x11a5e
movq %rbx, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa9c0
leaq 0xc7b2(%rip), %rsi      # 0x11a65
movl %eax, %edi
movq %r13, %rdx
movl $0x8f, %ecx
callq 0x4050
leaq 0xbdf1(%rip), %rdx      # 0x110ba
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc7ac(%rip), %rsi      # 0x11a90
movl %eax, %edi
movq %r13, %rdx
movl $0x90, %ecx
callq 0x4050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: suite_regex
void suite_regex(void) {
  pt_add_test(test_regex_basic, "Test Regex Basic", "Suite Regex");
  pt_add_test(test_regex_range, "Test Regex Range", "Suite Regex");
  pt_add_test(test_regex_string, "Test Regex String", "Suite Regex");
  pt_add_test(test_regex_lisp_comment, "Test Regex Lisp Comment", "Suite Regex");
  pt_add_test(test_regex_boundary, "Test Regex Boundary", "Suite Regex");
  pt_add_test(test_regex_newline, "Test Regex Newline", "Suite Regex");
  pt_add_test(test_regex_multiline, "Test Regex Multiline", "Suite Regex");
  pt_add_test(test_regex_dotall, "Test Regex Dotall", "Suite Regex");
}

// Assembly:
pushq %rbx
leaq -0xd0a(%rip), %rdi      # 0x4876
leaq 0xc741(%rip), %rsi      # 0x11cc8
leaq 0xc74b(%rip), %rbx      # 0x11cd9
movq %rbx, %rdx
callq 0x40c7
leaq -0x717(%rip), %rdi      # 0x4e86
leaq 0xc741(%rip), %rsi      # 0x11ce5
movq %rbx, %rdx
callq 0x40c7
leaq -0x6be(%rip), %rdi      # 0x4ef5
leaq 0xc73c(%rip), %rsi      # 0x11cf6
movq %rbx, %rdx
callq 0x40c7
leaq -0x5cb(%rip), %rdi      # 0x4ffe
leaq 0xc738(%rip), %rsi      # 0x11d08
movq %rbx, %rdx
callq 0x40c7
leaq -0xac7(%rip), %rdi      # 0x4b18
leaq 0xc73a(%rip), %rsi      # 0x11d20
movq %rbx, %rdx
callq 0x40c7
leaq -0x54c(%rip), %rdi      # 0x50a9
leaq 0xc738(%rip), %rsi      # 0x11d34
movq %rbx, %rdx
callq 0x40c7
leaq -0x47c(%rip), %rdi      # 0x518f
leaq 0xc735(%rip), %rsi      # 0x11d47
movq %rbx, %rdx
callq 0x40c7
leaq -0x318(%rip), %rdi      # 0x5309
leaq 0xc734(%rip), %rsi      # 0x11d5c
movq %rbx, %rdx
popq %rbx
jmp 0x40c7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/test.c
// Function: main
int main(int argc, char** argv) {
  (void) argc; (void) argv;
  pt_add_suite(suite_core);
  pt_add_suite(suite_regex);
  pt_add_suite(suite_grammar);
  pt_add_suite(suite_combinators);
  return pt_run();
}

// Assembly:
pushq %rax
leaq -0x2c4a(%rip), %rdi     # 0x29f2
callq 0x4228
leaq -0xd0(%rip), %rdi       # 0x5578
callq 0x4228
leaq -0x16d6(%rip), %rdi     # 0x3f7e
callq 0x4228
leaq -0x3d17(%rip), %rdi     # 0x1949
callq 0x4228
popq %rax
jmp 0x4230
nop
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: giveup(char*)
static void giveup(char* msg) {
  fprintf(stderr, "fifi: ");
  fprintf(stderr, "%s", msg);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2801(%rip), %r14      # 0x3fe0
movq (%r14), %rcx
leaq 0x9c0(%rip), %rdi       # 0x21a9
movl $0x6, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x10e0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x1160
movl $0x1, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/fifi/src/fifi.C
// Function: readline(_IO_FILE*)
static bool readline(FILE* fi) {
  linenum++;
  int n = 0, ch = getc(fi);
  until(n >= MAXSTR || ch == '\n' || ch < 0) {
    line[n++] = ch;
    ch = getc(fi);
  }
  unless(ch == '\n' || ch < 0) giveup("line too long!");
  line[n] = '\0';
  return !(ch < 0 && n == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x2898(%rip)            # 0x40e0
callq 0x1060
cmpl $0xa, %eax
sete %cl
testl %eax, %eax
sets %dl
xorl %r14d, %r14d
orb %cl, %dl
je 0x188f
testl %eax, %eax
sets %dl
orb %cl, %dl
je 0x18c4
testl %eax, %eax
setns %cl
movl %r14d, %eax
leaq 0x2879(%rip), %rdx      # 0x40f0
movb $0x0, (%rax,%rdx)
testl %r14d, %r14d
setne %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
leaq 0x2857(%rip), %r15      # 0x40f0
leaq 0x1(%r12), %r14
movb %al, (%r12,%r15)
movq %rbx, %rdi
callq 0x1060
cmpl $0xa, %eax
sete %cl
je 0x185f
cmpq $0xfe, %r12
ja 0x185f
movq %r14, %r12
testl %eax, %eax
jns 0x1899
jmp 0x185f
leaq 0x7e4(%rip), %rdi       # 0x20af
callq 0x17d1
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x20e0
movq (%rbx), %rcx
movq %rax, 0x18(%rcx)
testq %rax, %rax
je 0x30db
movq (%rbx), %rax
movq 0x18(%rax), %rcx
movq %rax, 0x20(%rcx)
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, (%rbx)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq (%rbx), %rax
movq %rcx, 0x10(%rax)
movq (%rbx), %rax
jmp 0x30dd
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x33df
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %r14
testq %rax, %rax
je 0x339a
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3391
callq 0x21a0
movq 0x10(%rbx), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33c2
movl $0x8, %r15d
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x33ac
movq %rax, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rbx
testq %r14, %r14
jne 0x3376
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/cmd.c
// Function: file_redirect
int file_redirect(cmd_t* cmd)
{
    int fd  = 0;
    
    switch (cmd->io->io_flag) {
        case    IOREAD:
        case    IOHERE:
            if (check_file_stat(cmd, 1, S_IREAD) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_RDONLY)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(0);
            dup2(fd, 0);
            break;
        case    IOWRITE:
            if (check_file_stat(cmd, 1, S_IWRITE) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_WRONLY    |
                            O_CREAT     |
                            O_TRUNC, 0666)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(cmd->io->io_unit);
            dup2(fd, cmd->io->io_unit);
            break;
        case    IOCAT:
            if (check_file_stat(cmd, 1, S_IWRITE) < 0)
                return -1;
            if ((fd = open(cmd->io->io_name,
                            O_WRONLY    |
                            O_CREAT     |
                            O_APPEND, 0666)) < 0) {
                perror("ysh: fopen");
                close(fd);

                return -1;
            }
            close(cmd->io->io_unit);
            dup2(fd, cmd->io->io_unit);
            break;
    }
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movzwl 0x2(%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3437
cmpl $0x3, %eax
je 0x3477
xorl %ebp, %ebp
movl $0x0, %ebx
cmpl $0x4, %eax
jne 0x34c8
movq %r14, %rdi
movl $0x1, %esi
movl $0x80, %edx
callq 0x34f0
testl %eax, %eax
js 0x34d1
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
movl $0x441, %esi            # imm = 0x441
jmp 0x349c
movq %r14, %rdi
movl $0x1, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x34f0
testl %eax, %eax
js 0x34d1
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %eax, %eax
callq 0x2470
movl %eax, %ebp
testl %eax, %eax
js 0x34dd
xorl %edi, %edi
callq 0x2060
movl %ebp, %edi
xorl %esi, %esi
jmp 0x34c3
movq %r14, %rdi
movl $0x1, %esi
movl $0x80, %edx
callq 0x34f0
testl %eax, %eax
js 0x34d1
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x2470
movl %eax, %ebp
testl %eax, %eax
js 0x34dd
movq 0x10(%r14), %rax
movswl (%rax), %edi
callq 0x2060
movq 0x10(%r14), %rax
movswl (%rax), %esi
movl %ebp, %edi
callq 0x2040
movl %ebp, %edi
callq 0x2060
jmp 0x34d6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8b4e(%rip), %rdi      # 0xc032
callq 0x2430
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x34c8
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movl %esi, %r14d
cmpl $0x1, %esi
jne 0x350f
movq 0x10(%rdi), %rax
addq $0x8, %rax
jmp 0x3513
movq 0x8(%rdi), %rax
movq (%rax), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2450
testl %eax, %eax
jns 0x3536
callq 0x2390
movl (%rax), %eax
cmpl $0x2, %eax
je 0x3565
cmpl $0xd, %eax
je 0x3587
movl 0x18(%rsp), %eax
movl %eax, %ecx
andl $0xf000, %ecx           # imm = 0xF000
leaq 0x8b13(%rip), %rsi      # 0xc05c
cmpl $0x4000, %ecx           # imm = 0x4000
je 0x3579
testl %ebp, %eax
je 0x3580
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x1, %r14d
je 0x3555
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8ac6(%rip), %rsi      # 0xc03d
jmp 0x3593
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
jmp 0x3593
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0x3593
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
leaq 0x8ac9(%rip), %rsi      # 0xc05c
movq 0xda46(%rip), %rax      # 0x10fe0
movq (%rax), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2440
jmp 0x3557
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl %esi, %edi
je 0x39e3
movl %edi, %ebx
callq 0x2040
cmpl $-0x1, %eax
je 0x39e5
popq %rbx
retq
movl %ebx, %edi
popq %rbx
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2070
cmpl $-0x1, %eax
jne 0x39fd
callq 0x2390
cmpl $0xa, (%rax)
jne 0x39fd
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x70, %edi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x425a
movl $0x0, (%rbx)
leaq 0x14b(%rip), %rax       # 0x42cc
movq %rax, 0x10(%rbx)
leaq 0x401(%rip), %rax       # 0x458d
movq %rax, 0x18(%rbx)
leaq 0x415(%rip), %rax       # 0x45ac
movq %rax, 0x20(%rbx)
leaq 0x46e(%rip), %rax       # 0x4610
movq %rax, 0x28(%rbx)
leaq 0x4cd(%rip), %rax       # 0x467a
movq %rax, 0x30(%rbx)
leaq 0x52d(%rip), %rax       # 0x46e5
movq %rax, 0x38(%rbx)
leaq 0x52b(%rip), %rax       # 0x46ee
movq %rax, 0x40(%rbx)
leaq 0x523(%rip), %rax       # 0x46f1
movq %rax, 0x48(%rbx)
leaq 0x596(%rip), %rax       # 0x476f
movq %rax, 0x50(%rbx)
leaq 0x630(%rip), %rax       # 0x4814
movq %rax, 0x58(%rbx)
leaq 0x776(%rip), %rax       # 0x4965
movq %rax, 0x60(%rbx)
movq $0x20, 0x68(%rbx)
movl $0x100, %edi            # imm = 0x100
callq 0x20e0
movq %rax, 0x8(%rbx)
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x425f
movq %rax, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x10, %edi
callq 0x20e0
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
testq %rax, %rax
je 0x427d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq %r12, (%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq %r12, 0x8(%rax)
incq %r13
cmpq $0x20, %r13
jne 0x421c
movq %rbx, (%r14)
xorl %ebp, %ebp
jmp 0x426c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x426c
movq %rbx, %rdi
callq 0x21a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0x425f
cmpq $0x0, 0x8(%rbx)
je 0x425f
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x42b3
callq 0x21a0
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
cmpq 0x68(%rbx), %r14
jb 0x428c
movq 0x8(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x8(%rbx)
movl $0x0, (%rbx)
jmp 0x425f
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
callq *0x18(%rdi)
testq %rax, %rax
je 0x45f8
movq %rax, %rbx
movq %rax, %rdi
callq 0x21b0
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x20e0
movq %rax, (%r14)
testq %rax, %rax
je 0x45ff
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2460
movb $0x0, (%r12,%r15)
xorl %eax, %eax
jmp 0x4604
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4604
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq *0x40(%rdi)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x4671
movq %r14, %rdi
callq *0x40(%r14)
testl %eax, %eax
jle 0x4667
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rax
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0x4662
incq %r15
movq %r14, %rdi
callq *0x40(%r14)
cltq
cmpq %rax, %r15
jl 0x463d
movl %r15d, %eax
jmp 0x4669
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq *0x40(%rdi)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x46dc
movq %r14, %rdi
callq *0x40(%r14)
testl %eax, %eax
jle 0x46d2
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0x46cd
incq %r15
movq %r14, %rdi
callq *0x40(%r14)
cltq
cmpq %rax, %r15
jl 0x46a7
movl %r15d, %eax
jmp 0x46d4
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rdi), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0x475e
movq %rsi, %r14
movq 0x8(%rdi), %r13
leaq -0x1(%r15), %rbp
xorl %r12d, %r12d
movq (%r13,%r12,8), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4c03
testl %eax, %eax
je 0x475b
movq (%r13,%rbp,8), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4c03
testl %eax, %eax
je 0x4755
incq %r12
cmpq %r15, %r12
jae 0x475e
leaq -0x1(%rbp), %rax
cmpq %rbp, %r12
movq %rax, %rbp
jl 0x4717
jmp 0x475e
notl %r12d
addl %r15d, %r12d
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x48(%rdi)
testl %eax, %eax
js 0x480e
movq (%rbx), %r15
movq 0x8(%r15), %rcx
movl %eax, %r14d
movq (%rcx,%r14,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x47af
callq 0x21a0
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r15
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x47d8
callq 0x21a0
movq 0x8(%r15), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
cmpl %r14d, (%rax)
jle 0x47f5
movq 0x8(%rax), %rax
movq 0x8(%rax,%r14,8), %rcx
movq %rcx, (%rax,%r14,8)
incq %r14
testq %rcx, %rcx
jne 0x47d8
movq (%rbx), %rax
movslq (%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rax)
movq 0x8(%rax), %rax
movq $0x0, -0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movslq (%r12), %r14
testq %r14, %r14
jle 0x4951
movq %rdi, %rbx
decq %r14
movl $0x1, %r15d
movq 0x8(%r12), %rax
cmpq $0x0, -0x8(%rax,%r15,8)
je 0x48b6
movq -0x8(%rax,%r15,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4868
callq 0x21a0
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x4895
callq 0x21a0
movq 0x8(%r12), %rax
movq -0x8(%rax,%r15,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax,%r15,8), %rdi
callq 0x21a0
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, -0x8(%rax,%r15,8)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
testq %rax, %rax
je 0x492e
movq (%rax), %rdi
testq %rdi, %rdi
je 0x48e4
callq 0x21a0
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x490f
callq 0x21a0
movq 0x8(%r12), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
callq 0x21a0
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r14,8)
movq (%rbx), %r12
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x4951
leaq 0x1(%r15), %rax
leaq -0x1(%r14), %rcx
cmpq %r14, %r15
movq %rcx, %r14
movq %rax, %r15
jl 0x4838
movl $0x0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/hash.c
// Function: release_shash
static
void release_shash(SHASH* shash)
{
    int     i       = 0,
            j       = 0;

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

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x4ae9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x4ad6
movslq (%rbx), %r14
testq %r14, %r14
jle 0x4ac5
decq %r14
movl $0x1, %r12d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
cmpq $0x0, -0x8(%rax,%r12,8)
je 0x4a26
movq -0x8(%rax,%r12,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x49ca
callq 0x21a0
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x4a02
callq 0x21a0
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq %r15, -0x8(%rax,%r12,8)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
testq %rax, %rax
je 0x4aa5
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4a4f
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, (%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x4a84
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq %r15, (%rax,%r14,8)
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x4ac5
leaq 0x1(%r12), %rax
leaq -0x1(%r14), %rcx
cmpq %r14, %r12
movq %rcx, %r14
movq %rax, %r12
jl 0x499c
movq 0x8(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4150
testl %eax, %eax
js 0x4b7c
movq %rbx, %rdi
callq *0x40(%rbx)
testl %eax, %eax
jle 0x4b6d
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %r14, %rdi
callq *0x10(%rax)
testl %eax, %eax
js 0x4b74
incq %r15
movq %rbx, %rdi
callq *0x40(%rbx)
cltq
cmpq %rax, %r15
jl 0x4b3f
movq 0x8(%rsp), %rax
jmp 0x4b7e
movq 0x8(%rsp), %rdi
callq *0x60(%rdi)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21b0
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x20e0
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movslq %ebp, %r12
movq (%rcx,%r12,8), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x4bf5
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2460
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
jmp 0x4bfa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x78, %edi
callq 0x20e0
testq %rax, %rax
je 0x4f38
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x87(%rip), %rcx        # 0x4f3f
movq %rcx, 0x18(%rax)
leaq 0x22e(%rip), %rcx       # 0x50f1
movq %rcx, 0x20(%rax)
leaq 0x322(%rip), %rcx       # 0x51f0
movq %rcx, 0x28(%rax)
leaq 0x41c(%rip), %rcx       # 0x52f5
movq %rcx, 0x30(%rax)
leaq 0x431(%rip), %rcx       # 0x5315
movq %rcx, 0x38(%rax)
leaq 0x447(%rip), %rcx       # 0x5336
movq %rcx, 0x40(%rax)
leaq 0x44c(%rip), %rcx       # 0x5346
movq %rcx, 0x48(%rax)
leaq 0x467(%rip), %rcx       # 0x536c
movq %rcx, 0x50(%rax)
leaq 0x48a(%rip), %rcx       # 0x539a
movq %rcx, 0x58(%rax)
leaq 0x495(%rip), %rcx       # 0x53b0
movq %rcx, 0x60(%rax)
leaq 0x49a(%rip), %rcx       # 0x53c0
movq %rcx, 0x68(%rax)
movl $0x0, 0x70(%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x4f3d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: set_cmd_argv_proc
static
int set_cmd_argv_proc(PROC** proc, char* const argv[])
{
    int     i       = 0,
            status  = 0;

    size_t  len     = 0;

    if ((*proc)->argv != NULL) {
        release_argv_proc(*proc);
        (*proc)->argc = 0;
        (*proc)->argv = NULL;
    }

    while (*(argv + (*proc)->argc) != NULL)
        (*proc)->argc++;

    if (((*proc)->argv = (char**)
            malloc(sizeof(char*) * ((*proc)->argc + 1))) == NULL) {
        status = -1; goto ERR;
    }
    while (i < (*proc)->argc) {
        len = strlen(*(argv + i));
        if ((*((*proc)->argv + i) = (char*)
                    malloc(sizeof(char) * (len + 1))) == NULL) {
            status = -2; goto ERR;
        }
        memcpy(*((*proc)->argv + i), *(argv + i), len);
        *(*((*proc)->argv + i) + len) = '\0';
        i++;
    }
    *((*proc)->argv + (*proc)->argc) = NULL;

    return 0;

ERR:
    switch (status) {
        case    -1:
        case    -2:
            break;
        case    -3:
            release_argv_proc(*proc);
            (*proc)->argc = 0;
            (*proc)->argv = NULL;
            break;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5121
callq 0x5797
movq (%r14), %rax
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %r15
movl 0x4(%r15), %eax
movslq %eax, %rcx
cmpq $0x0, (%rbx,%rcx,8)
je 0x514a
leaq (%rbx,%rcx,8), %rcx
addq $0x8, %rcx
incl %eax
cmpq $0x0, (%rcx)
leaq 0x8(%rcx), %rcx
jne 0x513a
movl %eax, 0x4(%r15)
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x20e0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x51da
movq (%r14), %r13
movl 0x4(%r13), %eax
testl %eax, %eax
jle 0x51c8
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x21b0
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x20e0
movq 0x8(%r13), %rcx
movq %rax, (%rcx,%r12,8)
testq %rax, %rax
je 0x51e1
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%rbx,%r12,8), %rsi
movq %r15, %rdx
callq 0x2460
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rax
movb $0x0, (%rax,%r15)
incq %r12
movq (%r14), %r13
movslq 0x4(%r13), %rax
cmpq %rax, %r12
jl 0x5170
movq 0x8(%r13), %rcx
cltq
movq $0x0, (%rcx,%rax,8)
xorl %eax, %eax
jmp 0x51e6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x51e6
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: set_env_proc
static
int set_env_proc(PROC** proc, char* const env[])
{
    int     status  = 0;

    size_t  i       = 0,
            envc    = 0,
            len     = 0;

    if ((*proc)->envp != NULL) {
        release_env_proc(*proc);
        (*proc)->envp = NULL;
    }

    while (*(env + envc) != NULL)
        envc++;
    if (((*proc)->envp = (char**)
                malloc(sizeof(char*) * envc)) == NULL) {
        status = -1; goto ERR;
    }
    while (i < envc) {
        len = strlen(*(env + i));
        if ((*((*proc)->envp + i) = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL) {
            status = -2; goto ERR;
        }
        memcpy(*((*proc)->envp + i), *(env + i), len);
        *(*((*proc)->envp + i) + len) = '\0';
        i++;
    }
    *((*proc)->envp + i) = NULL;

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            release_env_proc(*proc);
            (*proc)->envp = NULL;
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x521b
callq 0x57ed
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq $-0x1, %rbp
movl $0x8, %edi
addq $-0x8, %rdi
cmpq $0x0, 0x8(%r15,%rbp,8)
leaq 0x1(%rbp), %rbp
jne 0x5227
negq %rdi
callq 0x20e0
movq %rax, %r12
movq (%rbx), %rax
movq %r12, 0x10(%rax)
testq %r12, %r12
je 0x52ba
xorl %r14d, %r14d
testq %rbp, %rbp
je 0x52aa
movq (%r15,%r14,8), %rdi
callq 0x21b0
movq %rax, %r13
leaq 0x1(%rax), %rdi
callq 0x20e0
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx,%r14,8)
testq %rax, %rax
je 0x52c2
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rdi
movq (%r15,%r14,8), %rsi
movq %r13, %rdx
callq 0x2460
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rax
movb $0x0, (%rax,%r13)
incq %r14
cmpq %r14, %rbp
jne 0x5256
movq (%rbx), %rax
shlq $0x3, %r14
addq 0x10(%rax), %r14
xorl %r15d, %r15d
jmp 0x52dc
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x52c8
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
testq %r12, %r12
je 0x52e3
movq (%rbx), %rdi
callq 0x57ed
movq (%rbx), %r14
addq $0x10, %r14
movq $0x0, (%r14)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x5313
callq 0x57ed
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq *0x58(%rdi)
testl %eax, %eax
js 0x538d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq (%rsi), %rdi
testq %rdx, %rdx
je 0x5394
popq %rbx
jmp 0x2110
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
popq %rbx
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4e8c
testl %eax, %eax
js 0x5437
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testl %eax, %eax
js 0x543e
movq 0x8(%rsp), %rdi
callq *0x58(%rdi)
testl %eax, %eax
js 0x5445
movq 0x8(%rsp), %rdi
callq *0x50(%rdi)
movl %eax, %ebx
sarl $0x1f, %ebx
andl $-0x4, %ebx
jmp 0x544a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x544a
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x544a
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
leal 0x4(%rbx), %eax
cmpl $0x2, %eax
ja 0x545a
movq 0x8(%rsp), %rdi
callq *0x68(%rdi)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: init_mproc
int init_mproc(MPROC** mproc)
{
    int     i       = 0,
            status  = 0;

    MPROC*  mprc    = NULL;

    if ((mprc = (MPROC*)
                malloc(sizeof(MPROC))) == NULL) {
        status = -1; goto ERR;
    }
    if ((mprc->proc = (PROC**)
                malloc(sizeof(PROC*) * MPROC_MAX)) == NULL) {
        status = -2; goto ERR;
    } else {
        i = 0;
        while (i < MPROC_MAX && (mprc->proc[i] = NULL))
            i++;
    }
    {
        mprc->procs     = 0;
        mprc->proc_no   = 0;
        mprc->add       = add_mproc;
        mprc->del       = del_mproc;
        mprc->fork      = fork_mproc;
#ifdef  _GNU_SOURCE
        mprc->rfork     = rfork_mproc;
/* _GNU_SOURCE */
#endif
        mprc->is_parent = is_parent_mproc;
        mprc->is_child  = is_child_mproc;
        mprc->exec      = exec_mproc;
        mprc->wait      = wait_mproc;
        mprc->kill      = kill_mproc;
        mprc->killall   = killall_mproc;
        mprc->release   = release_mproc;
    }
    *mproc = mprc;

    return 0;

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

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x68, %edi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x551e
movl $0x100, %edi            # imm = 0x100
callq 0x20e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x5526
xorl %r14d, %r14d
movq %r14, (%rax)
movq %r14, 0x8(%rbx)
leaq 0x9b(%rip), %rax        # 0x5542
movq %rax, 0x10(%rbx)
leaq 0xc6(%rip), %rax        # 0x5578
movq %rax, 0x18(%rbx)
leaq 0x113(%rip), %rax       # 0x55d0
movq %rax, 0x20(%rbx)
leaq 0x14c(%rip), %rax       # 0x5614
movq %rax, 0x28(%rbx)
leaq 0x194(%rip), %rax       # 0x5667
movq %rax, 0x30(%rbx)
leaq 0x192(%rip), %rax       # 0x5670
movq %rax, 0x38(%rbx)
leaq 0x196(%rip), %rax       # 0x567f
movq %rax, 0x40(%rbx)
leaq 0x198(%rip), %rax       # 0x568c
movq %rax, 0x48(%rbx)
leaq 0x1d9(%rip), %rax       # 0x56d8
movq %rax, 0x50(%rbx)
leaq 0x1eb(%rip), %rax       # 0x56f5
movq %rax, 0x58(%rbx)
leaq 0x221(%rip), %rax       # 0x5736
movq %rax, 0x60(%rbx)
movq %rbx, (%r15)
jmp 0x5539
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x552c
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
testq %rbx, %rbx
je 0x5539
movq %rbx, %rdi
callq 0x21a0
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rcx
movslq 0x8(%rcx), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x1f, %rdx
jg 0x5577
movq (%rcx), %rax
movq %rsi, (%rax,%rdx,8)
movq (%rdi), %rax
movslq 0x8(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%rax)
movq (%rax), %rax
movq $0x0, 0x8(%rax,%rcx,8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, 0x8(%rcx)
jl 0x55cf
movq (%rcx), %rdx
movslq %esi, %rcx
cmpq $0x0, (%rdx,%rcx,8)
je 0x55cf
movq (%rdi), %rax
movslq 0x8(%rax), %rdx
cmpq %rdx, %rcx
jge 0x55b3
movq (%rax), %rax
movq 0x8(%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
testq %rdx, %rdx
jne 0x5593
movq (%rdi), %rax
movslq 0x8(%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x8(%rax)
movq (%rax), %rax
movq $0x0, -0x8(%rax,%rcx,8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x560a
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r14), %rdi
movq (%rdi,%r15), %rax
addq %r15, %rdi
callq *0x40(%rax)
movl %eax, 0xc(%r14)
testl %eax, %eax
je 0x560c
incq %rbx
movslq 0x8(%r14), %rax
addq $0x8, %r15
cmpq %rax, %rbx
jl 0x55e3
jmp 0x560c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq