LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x4dac
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x87(%rip), %rcx        # 0x4db3
movq %rcx, 0x18(%rax)
leaq 0x20b(%rip), %rcx       # 0x4f42
movq %rcx, 0x20(%rax)
leaq 0x301(%rip), %rcx       # 0x5043
movq %rcx, 0x28(%rax)
leaq 0x3ec(%rip), %rcx       # 0x5139
movq %rcx, 0x30(%rax)
leaq 0x401(%rip), %rcx       # 0x5159
movq %rcx, 0x38(%rax)
leaq 0x417(%rip), %rcx       # 0x517a
movq %rcx, 0x40(%rax)
leaq 0x41c(%rip), %rcx       # 0x518a
movq %rcx, 0x48(%rax)
leaq 0x437(%rip), %rcx       # 0x51b0
movq %rcx, 0x50(%rax)
leaq 0x45a(%rip), %rcx       # 0x51de
movq %rcx, 0x58(%rax)
leaq 0x465(%rip), %rcx       # 0x51f4
movq %rcx, 0x60(%rax)
leaq 0x46a(%rip), %rcx       # 0x5204
movq %rcx, 0x68(%rax)
movl $0x0, 0x70(%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x4db1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r15
cmpq $0x0, 0x8(%r15)
je 0x4f78
movq %r15, %rdi
callq 0x55ce
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 0x4f9e
leaq (%rbx,%rcx,8), %rcx
addq $0x8, %rcx
incl %eax
cmpq $0x0, (%rcx)
leaq 0x8(%rcx), %rcx
jne 0x4f8e
movl %eax, 0x4(%r15)
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x20e0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x502d
movq (%r14), %r13
movslq 0x4(%r13), %rax
testq %rax, %rax
jle 0x501d
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 0x5034
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%rbx,%r12,8), %rsi
movq %r15, %rdx
callq 0x2470
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 0x4fc5
movq 0x8(%r13), %rcx
movq $0x0, (%rcx,%rax,8)
xorl %eax, %eax
jmp 0x5039
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5039
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x506e
callq 0x5625
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq $-0x1, %r13
movl $0x8, %r12d
addq $-0x8, %r12
cmpq $0x0, 0x8(%r14,%r13,8)
leaq 0x1(%r13), %r13
jne 0x507b
movq %r12, %rdi
negq %rdi
callq 0x20e0
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x510b
testq %r13, %r13
je 0x50fd
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rdi
callq 0x21b0
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x20e0
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx,%rbp,8)
movq (%rbx), %rdi
testq %rax, %rax
je 0x5112
movq 0x10(%rdi), %rax
movq (%rax,%rbp,8), %rdi
movq (%r14,%rbp,8), %rsi
movq %r15, %rdx
callq 0x2470
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbp,8), %rax
movb $0x0, (%rax,%r15)
incq %rbp
cmpq %rbp, %r13
jne 0x50a9
movq (%rbx), %rax
movq 0x10(%rax), %rcx
subq %r12, %rcx
xorl %eax, %eax
jmp 0x5123
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x512a
callq 0x5625
movq (%rbx), %rcx
addq $0x10, %rcx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movq $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5157
callq 0x5625
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x51d1
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq (%rsi), %rdi
testq %rdx, %rdx
je 0x51d8
popq %rbx
jmp 0x2110
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
popq %rbx
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O3/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 0x4d00
testl %eax, %eax
js 0x527e
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testl %eax, %eax
js 0x5285
movq 0x8(%rsp), %rdi
callq *0x58(%rdi)
testl %eax, %eax
js 0x528c
movq 0x8(%rsp), %rdi
callq *0x50(%rdi)
xorl %ebx, %ebx
testl %eax, %eax
jns 0x5299
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
jmp 0x5291
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5299
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x5291
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movq 0x8(%rsp), %rdi
callq *0x68(%rdi)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x53af
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_O3/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 0x5408
movq (%rcx), %rdx
movslq %esi, %rcx
cmpq $0x0, (%rdx,%rcx,8)
je 0x5408
movq (%rdi), %rax
movslq 0x8(%rax), %rdx
cmpq %rdx, %rcx
jge 0x53f1
movq (%rax), %rax
movq 0x8(%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
testq %rdx, %rdx
jne 0x53cb
movq (%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq (%rax), %rax
movslq %edx, %rcx
movq $0x0, -0x8(%rax,%rcx,8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5443
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 0x5445
incq %rbx
movslq 0x8(%r14), %rax
addq $0x8, %r15
cmpq %rax, %rbx
jl 0x541c
jmp 0x5445
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
jle 0x5490
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r15), %rdi
movq (%rdi,%r12), %rax
addq %r12, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movl %eax, 0xc(%r15)
testl %eax, %eax
je 0x5492
incq %rbx
movslq 0x8(%r15), %rax
addq $0x8, %r12
cmpq %rax, %rbx
jl 0x5466
jmp 0x5492
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpl $0x0, 0x8(%rax)
jle 0x5503
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rax), %rdi
movq (%rdi,%r15), %rax
addq %r15, %rdi
movl %ebx, %esi
callq *0x48(%rax)
incq %r12
movq (%r14), %rax
movslq 0x8(%rax), %rcx
addq $0x8, %r15
cmpq %rcx, %r12
jl 0x54e1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x0, 0x8(%rdi)
jle 0x5561
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq *0x60(%rdi)
testl %eax, %eax
js 0x5564
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x5541
xorl %eax, %eax
jmp 0x5569
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x55cd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x55be
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x55b9
xorl %ecx, %ecx
movq (%rbx), %rdx
movslq %ecx, %r14
movq (%rdx,%r14,8), %rdi
testq %rdi, %rdi
je 0x55b2
callq *0x68(%rdi)
movq (%rbx), %rax
movq $0x0, (%rax,%r14,8)
incl %r14d
movl 0x8(%rbx), %eax
movl %r14d, %ecx
cmpl %eax, %ecx
jl 0x558c
movq (%rbx), %rdi
callq 0x21a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5623
movl 0x4(%rbx), %eax
testl %eax, %eax
js 0x5616
movq 0x8(%rbx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rdi
testq %rdi, %rdi
je 0x5606
callq 0x21a0
movq 0x8(%rbx), %rcx
movslq 0x4(%rbx), %rax
movq $0x0, (%rcx,%rax,8)
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
testl %eax, %eax
movl %ecx, %eax
jg 0x55e2
movq 0x8(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x567a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5663
xorl %r14d, %r14d
callq 0x21a0
movq 0x10(%rbx), %rax
movq $0x0, (%rax,%r14)
movq 0x10(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x5640
movq %rax, %rdi
callq 0x21a0
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/signal.c
// Function: set_signal_siglist
int set_signal_siglist(siglist_t* siglist)
{
    int i   = 0;

    if (siglist == NULL)
        return 1;

    while ((siglist + i)->sig != 0 && (siglist + i)->func != NULL) {
        if (signal((siglist + i)->sig, (siglist + i)->func) == SIG_ERR)
            return 2;
        i++;
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x56c8
movq %rdi, %r14
movl (%rdi), %edi
xorl %ebx, %ebx
testl %edi, %edi
je 0x56d4
addq $0x10, %r14
movq -0x8(%r14), %rsi
testq %rsi, %rsi
je 0x56d4
callq 0x2330
cmpq $-0x1, %rax
je 0x56cf
movl (%r14), %edi
addq $0x10, %r14
testl %edi, %edi
jne 0x56a7
jmp 0x56d4
movl $0x1, %ebx
jmp 0x56d4
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/signal.c
// Function: handl_zombie_proc
void handl_zombie_proc(void)
{
    struct  sigaction sa;

    sa.sa_handler   = SIG_IGN;
    sa.sa_flags     = SA_NOCLDWAIT;

    if (sigaction(SIGCHLD, &sa, NULL) == -1)
        exit(1);
}

// Assembly:
subq $0x98, %rsp
movq %rsp, %rsi
movq $0x1, (%rsi)
movl $0x2, 0x88(%rsi)
movl $0x11, %edi
xorl %edx, %edx
callq 0x22a0
cmpl $-0x1, %eax
je 0x5712
addq $0x98, %rsp
retq
movl $0x1, %edi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: ts_mblen
static
size_t ts_mblen(STRING* self)
{
    int     ch  = 0;

    size_t  c   = 0;

    char*   p   = NULL;

    if (self->empty(self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    p = self->c_str(self);
    setlocale(LC_CTYPE, T_STRING_LOCALE_VALUE);
    while (*p != '\0') {
        if ((ch = mblen(p, MB_CUR_MAX)) < 0) {
#ifdef  LIBRARY_VERBOSE
            print_error();
/* LIBRARY_VERBOSE */
#endif
            status = EINVALIDCHAR; goto ERR;
        } else {
            p += ch;
            c++;
        }
    }

    return c;

ERR:
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq *0xa0(%rdi)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x6909
leaq 0xa97e(%rip), %rax      # 0x11278
movl %ecx, (%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r14
leaq 0x5ab2(%rip), %rsi      # 0xc3ce
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2430
cmpb $0x0, (%r14)
je 0x68fe
xorl %ebx, %ebx
callq 0x21d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2310
testl %eax, %eax
js 0x6953
movl %eax, %eax
incq %rbx
cmpb $0x0, (%r14,%rax)
leaq (%r14,%rax), %r14
jne 0x692d
jmp 0x68fe
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x68f3
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: reconf
static
size_t reconf(STRING** self, size_t n)
{
    if (n)
        (*self)->alloc_size = n;

    (*self)->length = strlen((*self)->c_str(*self));

    return (*self)->size(*self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rsi, %rsi
je 0x6969
movq %rsi, (%rdi)
callq *0xc8(%rdi)
movq %rax, %rdi
callq 0x21b0
movq (%rbx), %rdi
movq %rax, 0x8(%rdi)
popq %rbx
jmpq *0x18(%rdi)
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: resize
static
int resize(STRING** self, size_t n, char const c)
{
    if (n == (*self)->size(*self))
        return 0;

    if (n < (*self)->size(*self)) {
        memset((*self)->string + n, '\0', (*self)->size(*self) - n);
        (*self)->length = strlen((*self)->string);
    } else {
        if (reallocate_memory(self, n + 1) < 0) {
            status = EMEMORYALLOC; goto ERR;
        } else {
            memset((*self)->string + (*self)->size(*self), c, n - (*self)->size(*self));
            *((*self)->string + n) = '\0';
            (*self)->length = strlen((*self)->string);
        }
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq *0x18(%rdi)
xorl %ebx, %ebx
cmpq %r15, %rax
je 0x6a1c
movq (%r14), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jbe 0x69cb
movq (%r14), %rdi
movq 0x10(%rdi), %r12
addq %r15, %r12
callq *0x18(%rdi)
subq %r15, %rax
xorl %ebx, %ebx
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2050
jmp 0x6a0c
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x6a27
movq (%r14), %rdi
movq 0x10(%rdi), %r12
callq *0x18(%rdi)
addq %rax, %r12
movq (%r14), %rdi
callq *0x18(%rdi)
movq %r15, %rdx
subq %rax, %rdx
movzbl %bpl, %esi
movq %r12, %rdi
callq 0x2050
movq (%r14), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax,%r15)
movq (%r14), %r14
movq 0x10(%r14), %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa84a(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x6a1c
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: reserve
static
int reserve(STRING** self, size_t s)
{
    if (!s) {
        status = EOUTOFRANGE; goto ERR;
    }

    (*self)->alloc_size = s + 1;
    if (((*self)->string = (char*)
                realloc((*self)->string, sizeof(char) * (*self)->alloc_size)) == NULL) {
#ifdef  LIBRARY_VERBOSE
        print_error();
/* LIBRARY_VERBOSE */
#endif
        status = EMEMORYALLOC; goto ERR;
    }

    if ((*self)->empty(*self)) {
        memset((*self)->string, '\0', (*self)->alloc_size);
    } else {
        (*self)->length = s;
        *((*self)->string + (*self)->length) = '\0';
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6a8a
movq %rsi, %rbx
movq %rdi, %r14
incq %rsi
movq (%rdi), %rax
movq %rsi, (%rax)
movq 0x10(%rax), %rdi
callq 0x2420
movq (%r14), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x6a91
movq (%r14), %rdi
callq *0xa0(%rdi)
movq (%r14), %rcx
testl %eax, %eax
je 0x6aa9
movq (%rcx), %rdx
movq 0x10(%rcx), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2050
jmp 0x6a9f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x6a96
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
leaq 0xa7db(%rip), %rax      # 0x11278
movl %ebx, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, 0x8(%rcx)
movq 0x10(%rcx), %rax
movb $0x0, (%rax,%rbx)
xorl %ebx, %ebx
jmp 0x6a9f
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: shrink_to_fit
static
int shrink_to_fit(STRING** self)
{
    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    } else {
        (*self)->alloc_size = (*self)->length + 1;
        if (((*self)->string = (char*)
                    realloc((*self)->string,
                        sizeof(char) * (*self)->alloc_size)) == NULL) {
#ifdef  LIBRARY_VERBOSE
            print_error();
/* LIBRARY_VERBOSE */
#endif
            status = EMEMORYALLOC; goto ERR;
        } else {
            *((*self)->string + (*self)->length) = '\0';
        }
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl %eax, %ecx
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %ecx, %ecx
je 0x6adc
leaq 0xa7a0(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
jmp 0x6b0f
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
incq %rsi
movq %rsi, (%rax)
callq 0x2420
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x6b11
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
popq %rbx
retq
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x6ad1
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: count
static
size_t count(STRING* self, char* const str)
{
    size_t  n       = 0,
            len     = 0;

    char*   p       = NULL;

    if (str == NULL) {
        status = EARGISNULPTR; goto ERR;
    }
    if (self->empty(self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if (self->size(self) < (len = strlen(str)) ||
            !len)
        return 0;

    p = self->c_str(self);
    while (*p != '\0') {
        if (memcmp(p, str, len) == 0) {
            n++;
            p += len;
        } else {
            p++;
        }
    }

    return n;

ERR:
    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6ba1
movq %rsi, %rbx
movq %rdi, %r15
callq *0xa0(%rdi)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x6ba6
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
decq %rax
cmpq %r12, %rax
jae 0x6bc1
movq %r15, %rdi
callq *0xc8(%r15)
cmpb $0x0, (%rax)
je 0x6bc1
movq %rax, %r12
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22c0
xorl %ecx, %ecx
movq %r14, %rdx
testl %eax, %eax
sete %al
je 0x6b8f
movl $0x1, %edx
movb %al, %cl
addq %rcx, %r15
cmpb $0x0, (%r12,%rdx)
leaq (%r12,%rdx), %r12
jne 0x6b70
jmp 0x6bb2
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
leaq 0xa6cb(%rip), %rax      # 0x11278
movl %ecx, (%rax)
movslq %ecx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x6bb2
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: assign
static
int assign(STRING** self, char* const str)
{
    if (str == NULL) {
        status = EARGISNULPTR; goto ERR;
    }
    if ((*self)->string != NULL) {
        free((*self)->string);
        (*self)->string = NULL;
    }
    (*self)->length = strlen(str);
    if (allocate_memory(self, (*self)->length + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memcpy((*self)->string, str, (*self)->length);
        *((*self)->string + (*self)->length) = '\0';
    }

    return 0;

ERR:
    switch (status) {
        case    EARGISNULPTR:
        case    EMEMORYALLOC:
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6c81
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x6bfb
callq 0x21a0
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq (%rbx), %r15
movq %r14, %rdi
callq 0x21b0
movq %rax, 0x8(%r15)
incq %rax
movq (%r15), %rdi
cmpq %rax, %rdi
jae 0x6c3c
leaq 0x400(%rdi), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rdi, %rax
notq %rax
addq %rcx, %rax
andq $-0x400, %rax           # imm = 0xFC00
addq %rax, %rdi
addq $0x400, %rdi            # imm = 0x400
movq %rdi, (%r15)
callq 0x20e0
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x6c88
movq (%rbx), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x2050
movq (%rbx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x2470
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb $0x0, (%rax,%rcx)
jmp 0x6c96
movl $0xfffffffb, %ebp       # imm = 0xFFFFFFFB
jmp 0x6c8d
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
leaq 0xa5e4(%rip), %rax      # 0x11278
movl %ebp, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: prepend
static
int prepend(STRING** self, char* const str)
{
    if (str == NULL)
        return (status = EARGISNULPTR);

    if (reallocate_memory(self, strlen(str) + 1) < 0)
        return (status = EMEMORYALLOC);

    return (*self)->insert(self, 0, str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6ce5
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x6cf9
movq (%r14), %rax
movq 0x88(%rax), %rax
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0xa58c(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6d0b
leaq 0xa578(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: append
static
int append(STRING** self, char* const str)
{
    if (str == NULL) {
        status = EARGISNULPTR; goto ERR;
    }
    if (reallocate_memory(self, strlen(str) + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memcpy((*self)->string + (*self)->length, str, strlen(str));
        (*self)->length += strlen(str);
        *((*self)->string + (*self)->length) = '\0';
    }

    return 0;

ERR:
    switch (status) {
        case    EARGISNULPTR:
        case    EMEMORYALLOC:
            break;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x6d7b
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x6d82
movq (%rbx), %rax
movq 0x10(%rax), %r15
addq 0x8(%rax), %r15
movq %r14, %rdi
callq 0x21b0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2470
movq %r14, %rdi
callq 0x21b0
movq (%rbx), %rcx
addq 0x8(%rcx), %rax
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movb $0x0, (%rcx,%rax)
xorl %eax, %eax
jmp 0x6d90
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6d87
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
leaq 0xa4ea(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: push_back
static
int push_back(STRING** self, char const c)
{
    if (c == '\0')
        return 0;

    if (reallocate_memory(self, sizeof(c) + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        *((*self)->string + (*self)->length) = c;
        *((*self)->string + (*self)->length + 1) = '\0';
        (*self)->length += 1;
    }

    return 0;

ERR:
    switch (status) {
        case    EMEMORYALLOC:
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x6dee
movq %rdi, %r14
movl $0x2, %esi
callq 0x9b9c
testl %eax, %eax
js 0x6ddc
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb %bpl, (%rax,%rcx)
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb $0x0, 0x1(%rax,%rcx)
movq (%r14), %rax
incq 0x8(%rax)
jmp 0x6dee
leaq 0xa495(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: pop_back
static
void pop_back(STRING** self)
{
    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY;
    } else {
        (*self)->length -= 1;
        *((*self)->string + (*self)->length) = '\0';
    }

    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x6e15
leaq 0xa46b(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x6e2d
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
leaq -0x1(%rcx), %rsi
movq %rsi, 0x8(%rax)
movb $0x0, -0x1(%rdx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: insert
static
int insert(STRING** self, size_t pos, char* const str)
{
    if (str == NULL) {
        status = EARGISNULPTR; goto ERR;
    }
    if (!is_in_range(*self, pos)) {
        status = EOUTOFRANGE; goto ERR;
    }
    if (reallocate_memory(self, strlen(str) + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memmove((*self)->string + strlen(str) + pos,
                (*self)->string + pos,
                strlen((*self)->string + pos));
        memcpy((*self)->string + pos, str, strlen(str));
        (*self)->length = strlen((*self)->string);
        *((*self)->string + (*self)->length) = '\0';
    }

    return 0;

ERR:
    switch (status) {
        case    EARGISNULPTR:
        case    EOUTOFRANGE:
        case    EMEMORYALLOC:
            break;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x6e75
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jae 0x6e8c
leaq 0xa413(%rip), %rax      # 0x11278
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6f1a
leaq 0xa3fc(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6f1a
movq %r14, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x6f08
movq (%rbx), %rax
movq 0x10(%rax), %r12
addq %r15, %r12
movq %r14, %rdi
callq 0x21b0
leaq (%rax,%r12), %r13
movq %r12, %rdi
callq 0x21b0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2340
movq (%rbx), %rax
addq 0x10(%rax), %r15
movq %r14, %rdi
callq 0x21b0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2470
movq (%rbx), %r14
movq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
jmp 0x6f1a
leaq 0xa369(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: erase
static
int erase(STRING** self, size_t pos, size_t n)
{
    if (!is_in_range(*self, pos) ||
            !is_in_range(*self, pos + n)) {
        status = EOUTOFRANGE; goto ERR;
    }

    if (n == 0)
        n = (*self)->size(*self) - pos;

    memmove((*self)->string + pos,
            (*self)->string + pos + n,
            strlen((*self)->string + pos + n));
    memset((*self)->string + (*self)->length - n, '\0', n);
    (*self)->length = strlen((*self)->c_str(*self));

    return 0;

ERR:
    switch (status) {
        case    EOUTOFRANGE:
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jb 0x6f4f
movq (%rbx), %rdi
leaq (%r14,%r15), %r12
callq *0x18(%rdi)
cmpq %r12, %rax
jae 0x6f63
leaq 0xa322(%rip), %rax      # 0x11278
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x6fc7
testq %r14, %r14
jne 0x6f74
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r14
subq %r15, %r14
movq (%rbx), %rax
addq 0x10(%rax), %r15
leaq (%r15,%r14), %r12
movq %r12, %rdi
callq 0x21b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2340
movq (%rbx), %rax
movq 0x10(%rax), %rdi
addq 0x8(%rax), %rdi
subq %r14, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
movq %r14, %rdx
callq 0x2050
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %rdi
callq 0x21b0
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: replace
static
int replace(STRING** self, size_t pos, size_t n, char* const str)
{
    if (str == NULL)
        return (status = EARGISNULPTR);

    if ((*self)->erase(self, pos, n) < 0)
        return status;

    if ((*self)->insert(self, pos, str) < 0)
        return status;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rcx, %rcx
je 0x7012
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x90(%rax)
testl %eax, %eax
js 0x7026
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x88(%rax)
leaq 0xa26d(%rip), %rcx      # 0x11278
sarl $0x1f, %eax
andl (%rcx), %eax
jmp 0x702f
leaq 0xa25f(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x702f
leaq 0xa24b(%rip), %rax      # 0x11278
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: sub
static
int sub(STRING** self, char* const src, char* const dest)
{
    size_t  pos = 0,
            len = 0;

    char*   p   = NULL;

    if (src == NULL || dest == NULL)
        return (status = EARGISNULPTR);
    if ((*self)->empty(*self) ||
            !(len = strlen(src)))
        return (status = ESTRISEMPTY);

    p = (*self)->c_str(*self);
    while (*p != '\0' && memcmp(p, src, len)) {
        p++;
        pos++;
    }
    if (*p != '\0')
        (*self)->replace(self, pos, len, dest);
    else
        return (status = ESTRNOTFOUND);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0x7064
leaq 0xa221(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x708c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x709b
leaq 0xa1f7(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x21b0
testq %rax, %rax
je 0x707a
movq %rax, %r12
movq (%r14), %rdi
callq *0xc8(%rdi)
cmpb $0x0, (%rax)
je 0x70df
movq %rax, %r13
xorl %ebp, %ebp
movq %r13, %rdi
addq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22c0
testl %eax, %eax
je 0x70f3
cmpb $0x0, 0x1(%r13,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x70be
leaq 0xa192(%rip), %rax      # 0x11278
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x708c
movq (%r14), %rax
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x98(%rax)
xorl %eax, %eax
jmp 0x708c
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: gsub
static
int gsub(STRING** self, char* const src, char* const dest)
{
    int     cnt = 0;

    while ((*self)->sub(self, src, dest) == 0)
        cnt++;
    if ((WSTRISEMPTY(status) || WSTRNOTFOUND(status)) && cnt)
        status = 0; /* success */

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebp
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x1f0(%rax)
decl %ebp
testl %eax, %eax
je 0x7121
leaq 0xa138(%rip), %rcx      # 0x11278
movl (%rcx), %eax
leal 0x6(%rax), %edx
testl $0xfffffffd, %edx       # imm = 0xFFFFFFFD
sete %dl
testl %ebp, %ebp
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x7165
movl $0x0, (%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: at
static
char at(STRING* self, size_t pos)
{
    char    c   =   '\0';

    if (!is_in_range(self, pos))
        status = EOUTOFRANGE;
    else
        c = *(self->c_str(self) + pos - 1);

    return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq *0x18(%rdi)
cmpq %rbx, %rax
jae 0x7193
leaq 0xa0ef(%rip), %rax      # 0x11278
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x71a1
movq %r14, %rdi
callq *0xc8(%r14)
movb -0x1(%rax,%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: back
static
char* back(STRING* self)
{
    if (self->empty(self)) {
        status = ESTRISEMPTY;

        return NULL;
    }

    return self->c_str(self) + self->size(self) - 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq *0xa0(%rdi)
testl %eax, %eax
je 0x7204
leaq 0xa07e(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %eax, %eax
jmp 0x721c
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r14
movq %rbx, %rdi
callq *0x18(%rbx)
addq %r14, %rax
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: substr
static
int substr(STRING* self, size_t pos, size_t n, STRING** dest)
{
    if (n == 0)
        n = self->size(self) - pos;

    if (!is_in_range(self, pos) ||
            !is_in_range(self, pos + n)) {
        status = EOUTOFRANGE; goto ERR;
    }

    if ((*dest = new_string(NULL)) == NULL) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        (*dest)->length = n;
    }
    if ((*dest)->reserve(dest, (*dest)->size(*dest)) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memcpy((*dest)->c_str(*dest),
                self->c_str(self) + pos, (*dest)->size(*dest));
        *((*dest)->string + (*dest)->size(*dest)) = '\0';
    }

    return 0;

ERR:
    switch (status) {
        case    ESTRISEMPTY:
        case    EOUTOFRANGE:
            break;
        case    EMEMORYALLOC:
            if (*dest != NULL) {
                (*dest)->release(*dest);
                *dest = NULL;
            }
            break;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
jne 0x7250
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
subq %r14, %r12
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r14, %rax
jb 0x726c
leaq (%r12,%r14), %r13
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r13, %rax
jae 0x7288
leaq 0xa005(%rip), %rax      # 0x11278
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x6460
movq %rax, (%rbx)
testq %rax, %rax
je 0x72f1
movq %r12, 0x8(%rax)
movq 0x40(%rax), %r12
movq %rax, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq *%r12
testl %eax, %eax
js 0x7308
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %r12
movq %r15, %rdi
callq *0xc8(%r15)
addq %rax, %r14
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2470
movq (%rbx), %rdi
movq 0x10(%rdi), %rbx
callq *0x18(%rdi)
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
jmp 0x727e
leaq 0x9f80(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x727e
leaq 0x9f69(%rip), %r14      # 0x11278
movl $0xfffffffd, (%r14)     # imm = 0xFFFFFFFD
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x72fe
callq *0x268(%rdi)
movq $0x0, (%rbx)
movl (%r14), %eax
jmp 0x727e
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: c_substr
static
int c_substr(STRING* self, size_t pos, size_t n, char** dest)
{
    if (n == 0)
        n = self->size(self) - pos;

    if (!is_in_range(self, pos) ||
            !is_in_range(self, pos + n)){
        status = EOUTOFRANGE; goto ERR;
    }

    if ((*dest = (char*)
                malloc(sizeof(char) * (n + 1))) == NULL) {
#ifdef  LIBRARY_VERBOSE
        print_error();
/* LIBRARY_VERBOSE */
#endif
        status = EMEMORYALLOC; goto ERR;
    } else {
        memcpy(*dest, self->c_str(self) + pos, n);
        *((*dest) + n) = '\0';
    }

    return 0;

ERR:
    switch (status) {
        case    ESTRISEMPTY:
        case    EOUTOFRANGE:
        case    EMEMORYALLOC:
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
jne 0x735d
movq %r12, %rdi
callq *0x18(%r12)
movq %rax, %r14
subq %r15, %r14
movq %r12, %rdi
callq *0x18(%r12)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %r15, %rax
jb 0x73c1
leaq (%r14,%r15), %r13
movq %r12, %rdi
callq *0x18(%r12)
cmpq %r13, %rax
jb 0x73c1
leaq 0x1(%r14), %rdi
callq 0x20e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x73bc
movq %rax, %r13
movq %r12, %rdi
callq *0xc8(%r12)
addq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2470
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
xorl %ebp, %ebp
jmp 0x73ca
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
leaq 0x9eb0(%rip), %rax      # 0x11278
movl %ebp, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: copy
static
int copy(STRING* self, STRING** dest)
{
    if (self->empty(self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if ((*dest = new_string(NULL)) == NULL)
        goto ERR;
    if ((*dest)->reserve(dest, self->capacity(self) - 1) < 0)
        goto ERR;
    if ((*dest)->assign(dest, self->c_str(self)) < 0)
        goto ERR;

    return 0;

ERR:
    if (*dest != NULL) {
        (*dest)->release(*dest);
        *dest = NULL;
    }

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq *0xa0(%rdi)
testl %eax, %eax
je 0x7d39
leaq 0x955c(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7d85
callq *0x268(%rdi)
movq $0x0, (%rbx)
jmp 0x7d85
xorl %edi, %edi
callq 0x6460
movq %rax, (%rbx)
testq %rax, %rax
je 0x7d85
movq 0x40(%rax), %r15
movq %r14, %rdi
callq *0x28(%r14)
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
js 0x7d22
movq (%rbx), %rax
movq 0x58(%rax), %r15
movq %r14, %rdi
callq *0xc8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq *%r15
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x7d8e
jmp 0x7d22
leaq 0x94ec(%rip), %rax      # 0x11278
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq