LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x492f
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq (%rsi), %rdi
testq %rdx, %rdx
je 0x4934
popq %rbx
jmp 0x2110
pushq $-0x1
popq %rax
popq %rbx
retq
popq %rbx
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdi)
callq 0x44e0
testl %eax, %eax
js 0x49d0
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testl %eax, %eax
js 0x49d5
movq 0x8(%rsp), %rdi
callq *0x58(%rdi)
testl %eax, %eax
js 0x49d9
movq 0x8(%rsp), %rdi
callq *0x50(%rdi)
xorl %ebx, %ebx
testl %eax, %eax
jns 0x49e4
pushq $-0x4
jmp 0x49db
pushq $-0x1
popq %rbx
jmp 0x49e4
pushq $-0x2
jmp 0x49db
pushq $-0x3
popq %rbx
movq 0x8(%rsp), %rdi
callq *0x68(%rdi)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x68
popq %rdi
callq 0x20e0
movq %rax, %rbx
testq %rax, %rax
je 0x4aa6
movl $0x100, %edi            # imm = 0x100
callq 0x20e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4aaa
andq $0x0, (%rax)
andq $0x0, 0x8(%rbx)
leaq 0x8f(%rip), %rax        # 0x4abc
movq %rax, 0x10(%rbx)
leaq 0xb6(%rip), %rax        # 0x4aee
movq %rax, 0x18(%rbx)
leaq 0xff(%rip), %rax        # 0x4b42
movq %rax, 0x20(%rbx)
leaq 0x131(%rip), %rax       # 0x4b7f
movq %rax, 0x28(%rbx)
leaq 0x173(%rip), %rax       # 0x4bcc
movq %rax, 0x30(%rbx)
leaq 0x171(%rip), %rax       # 0x4bd5
movq %rax, 0x38(%rbx)
leaq 0x175(%rip), %rax       # 0x4be4
movq %rax, 0x40(%rbx)
leaq 0x177(%rip), %rax       # 0x4bf1
movq %rax, 0x48(%rbx)
leaq 0x1b1(%rip), %rax       # 0x4c36
movq %rax, 0x50(%rbx)
leaq 0x1c1(%rip), %rax       # 0x4c51
movq %rax, 0x58(%rbx)
leaq 0x1f6(%rip), %rax       # 0x4c91
movq %rax, 0x60(%rbx)
movq %rbx, (%r14)
xorl %ebp, %ebp
jmp 0x4ab5
pushq $-0x1
jmp 0x4aac
pushq $-0x2
popq %rbp
movq %rbx, %rdi
callq 0x21a0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
movslq 0x8(%rax), %rcx
cmpq $0x1f, %rcx
jle 0x4acd
pushq $-0x1
popq %rax
retq
movq (%rax), %rax
movq %rsi, (%rax,%rcx,8)
movq (%rdi), %rax
movslq 0x8(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%rax)
movq (%rax), %rax
andq $0x0, 0x8(%rax,%rcx,8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
cmpl $0x2, 0x8(%rcx)
jl 0x4b41
movq (%rcx), %rdx
movslq %esi, %rcx
cmpq $0x0, (%rdx,%rcx,8)
je 0x4b41
movq (%rdi), %rax
movslq 0x8(%rax), %rdx
cmpq %rdx, %rcx
jge 0x4b2d
movq (%rax), %rax
movq 0x8(%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
testq %rdx, %rdx
jne 0x4b07
movq (%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq (%rax), %rax
movslq %edx, %rcx
andq $0x0, -0x8(%rax,%rcx,8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x4b76
movq (%rbx), %rdi
movq (%rdi,%r15), %rax
addq %r15, %rdi
callq *0x40(%rax)
movl %eax, 0xc(%rbx)
testl %eax, %eax
je 0x4b76
incq %r14
addq $0x8, %r15
jmp 0x4b50
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x4bbd
movq (%r14), %rdi
movq (%rdi,%r12), %rax
addq %r12, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movl %eax, 0xc(%r14)
testl %eax, %eax
je 0x4bbd
incq %r15
addq $0x8, %r12
jmp 0x4b93
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r12
jge 0x4c28
movq (%rax), %rdi
movq (%rdi,%r15), %rax
addq %r15, %rdi
movl %ebx, %esi
callq *0x48(%rax)
incq %r12
addq $0x8, %r15
jmp 0x4c04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: killall_mproc
static
int killall_mproc(MPROC* mproc, int sig)
{
    int     i   = 0;

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

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
pushq $-0x1
popq %r15
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x4c86
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
callq *0x60(%rdi)
incq %r12
testl %eax, %eax
jns 0x4c67
movl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ce4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4cd5
xorl %eax, %eax
movl 0x8(%rbx), %ecx
movq (%rbx), %rdi
movl %eax, %r14d
cmpl %ecx, %r14d
jge 0x4cd0
movq (%rdi,%r14,8), %rax
testq %rax, %rax
je 0x4cae
movq %rax, %rdi
callq *0x68(%rax)
movq (%rbx), %rax
andq $0x0, (%rax,%r14,8)
leal 0x1(%r14), %eax
jmp 0x4ca5
callq 0x21a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x8(%rdi)
je 0x4d2a
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movq 0x8(%rbx), %rdi
testl %eax, %eax
js 0x4d1f
movl %eax, %ecx
movq (%rdi,%rcx,8), %rdi
testq %rdi, %rdi
je 0x4d18
callq 0x21a0
movq 0x8(%rbx), %rcx
movslq 0x4(%rbx), %rax
andq $0x0, (%rcx,%rax,8)
decl %eax
movl %eax, 0x4(%rbx)
jmp 0x4cf3
callq 0x21a0
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/proc.c
// Function: release_env_proc
static
void release_env_proc(PROC* proc)
{
    size_t  i   = 0;

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

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4da7
xorl %r14d, %r14d
movq (%rdi,%r14), %rax
testq %rax, %rax
je 0x4d9d
movq %rax, %rdi
callq 0x21a0
movq 0x10(%rbx), %rax
andq $0x0, (%rax,%r14)
movq 0x10(%rbx), %rdi
addq $0x8, %r14
jmp 0x4d79
callq 0x21a0
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x4dfe
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
pushq $0x2
popq %rbp
movl -0x8(%rbx), %edi
xorl %eax, %eax
testl %edi, %edi
je 0x4df7
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x4df7
callq 0x2330
addq $0x10, %rbx
cmpq $-0x1, %rax
jne 0x4dd5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x11
popq %rdi
xorl %edx, %edx
callq 0x22a0
cmpl $-0x1, %eax
je 0x4e34
addq $0x98, %rsp
retq
pushq $0x1
popq %rdi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq *0xa0(%rdi)
testl %eax, %eax
je 0x5e40
pushq $-0x4
popq %rbp
leaq 0xb444(%rip), %rax      # 0x11278
movl %ebp, (%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r14
leaq 0x553f(%rip), %rsi      # 0xb392
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2430
pushq $-0x2
popq %rbp
cmpb $0x0, (%r14)
je 0x5e38
callq 0x21d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2310
testl %eax, %eax
js 0x5e2d
movl %eax, %eax
addq %rax, %r14
incq %rbx
jmp 0x5e5f
// File: /workspace/github_c_makefile_star2_O2/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 0x5e92
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_O2/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 0x5f45
movq (%r14), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jbe 0x5ef4
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 0x5f35
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x8db8
testl %eax, %eax
js 0x5f50
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 0xb321(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
pushq $-0x3
popq %rbx
jmp 0x5f45
// File: /workspace/github_c_makefile_star2_O2/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 0x5fb1
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 0x5fb5
movq (%r14), %rdi
callq *0xa0(%rdi)
movq (%r14), %rcx
testl %eax, %eax
je 0x5fcb
movq (%rcx), %rdx
movq 0x10(%rcx), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2050
jmp 0x5fc1
pushq $-0x1
jmp 0x5fb7
pushq $-0x3
popq %rbx
leaq 0xb2b9(%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 0x5fc1
// File: /workspace/github_c_makefile_star2_O2/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)
testl %eax, %eax
je 0x5ffa
pushq $-0x4
popq %rax
leaq 0xb282(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
jmp 0x602d
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 0x602f
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
popq %rbx
retq
pushq $-0x3
jmp 0x5fee
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x6059
movq %rsi, %rbx
movq %rdi, %r15
callq *0xa0(%rdi)
testl %eax, %eax
je 0x6075
pushq $-0x4
jmp 0x605b
pushq $-0x5
popq %rax
leaq 0xb215(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
movslq %eax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
decq %rax
cmpq %r12, %rax
jae 0x60d4
movq %r15, %rdi
callq *0xc8(%r15)
movq %rax, %r12
xorl %r15d, %r15d
pushq $0x1
popq %r13
cmpb $0x0, (%r12)
je 0x6068
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22c0
xorl %ecx, %ecx
movq %r14, %rdx
testl %eax, %eax
sete %al
je 0x60ca
movq %r13, %rdx
movb %al, %cl
addq %rcx, %r15
addq %rdx, %r12
jmp 0x60a6
xorl %r15d, %r15d
jmp 0x6068
// File: /workspace/github_c_makefile_star2_O2/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 0x6173
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x610b
callq 0x21a0
movq (%rbx), %rax
andq $0x0, 0x10(%rax)
movq (%rbx), %r15
movq %r14, %rdi
callq 0x21b0
movq %rax, 0x8(%r15)
incq %rax
movq (%r15), %rdi
cmpq %rax, %rdi
jae 0x612e
addq $0x400, %rdi            # imm = 0x400
movq %rdi, (%r15)
jmp 0x611d
callq 0x20e0
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x6177
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 0x6183
pushq $-0x5
jmp 0x6179
pushq $-0x3
popq %rbp
leaq 0xb0f7(%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_O2/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 0x61d2
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x8db8
testl %eax, %eax
js 0x61e3
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 0xb09f(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
jmp 0x61f2
leaq 0xb08e(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6263
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x8db8
testl %eax, %eax
js 0x6267
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 0x6273
pushq $-0x5
jmp 0x6269
pushq $-0x3
popq %rax
leaq 0xb007(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62cd
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0x8db8
testl %eax, %eax
js 0x62bd
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 0x62cd
leaq 0xafb4(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
pushq $-0x3
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x62f4
leaq 0xaf8c(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x630c
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_O2/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 0x634e
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jae 0x6362
leaq 0xaf34(%rip), %rax      # 0x11278
orl $-0x1, (%rax)
pushq $-0x1
jmp 0x63ed
leaq 0xaf23(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
jmp 0x63ed
movq %r14, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x8db8
testl %eax, %eax
js 0x63de
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 0x63ee
leaq 0xae93(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
pushq $-0x3
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6423
movq (%rbx), %rdi
leaq (%r14,%r15), %r12
callq *0x18(%rdi)
cmpq %r12, %rax
jae 0x6432
leaq 0xae4e(%rip), %rax      # 0x11278
orl $-0x1, (%rax)
pushq $-0x1
popq %rbp
jmp 0x6496
testq %r14, %r14
jne 0x6443
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_O2/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 0x64e1
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x90(%rax)
testl %eax, %eax
js 0x64f3
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x88(%rax)
leaq 0xad9e(%rip), %rcx      # 0x11278
sarl $0x1f, %eax
andl (%rcx), %eax
jmp 0x64fc
leaq 0xad90(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
popq %rax
jmp 0x64fc
leaq 0xad7e(%rip), %rax      # 0x11278
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x652e
leaq 0xad54(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
jmp 0x6553
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x6563
leaq 0xad2d(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
pushq $-0x4
popq %rax
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 0x6544
movq %rax, %r12
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %rbp
xorl %r13d, %r13d
cmpb $0x0, (%rbp,%r13)
je 0x65a4
movq %rbp, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22c0
testl %eax, %eax
je 0x65b5
incq %r13
jmp 0x6582
leaq 0xaccd(%rip), %rax      # 0x11278
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
pushq $-0x6
jmp 0x6553
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x98(%rax)
xorl %eax, %eax
jmp 0x6554
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x1f0(%rax)
decl %ebp
testl %eax, %eax
je 0x65e1
leaq 0xac78(%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 0x6622
andl $0x0, (%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x664d
leaq 0xac32(%rip), %rax      # 0x11278
orl $-0x1, (%rax)
xorl %eax, %eax
jmp 0x665b
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_O2/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 0x66be
leaq 0xabc4(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %eax, %eax
jmp 0x66d6
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_O2/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 0x670a
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
subq %r14, %r12
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r14, %rax
jb 0x6726
leaq (%r12,%r14), %r13
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r13, %rax
jae 0x673d
leaq 0xab4b(%rip), %rax      # 0x11278
orl $-0x1, (%rax)
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x59a4
movq %rax, (%rbx)
testq %rax, %rax
je 0x67a6
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 0x67ba
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 0x6733
leaq 0xaacb(%rip), %rax      # 0x11278
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
pushq $-0x3
jmp 0x6732
leaq 0xaab7(%rip), %r14      # 0x11278
movl $0xfffffffd, (%r14)     # imm = 0xFFFFFFFD
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x67b3
callq *0x268(%rdi)
andq $0x0, (%rbx)
movl (%r14), %eax
jmp 0x6733
// File: /workspace/github_c_makefile_star2_O2/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 0x680c
movq %r12, %rdi
callq *0x18(%r12)
movq %rax, %r14
subq %r15, %r14
movq %r12, %rdi
callq *0x18(%r12)
pushq $-0x1
popq %rbp
cmpq %r15, %rax
jb 0x686c
leaq (%r14,%r15), %r13
movq %r12, %rdi
callq *0x18(%r12)
cmpq %r13, %rax
jb 0x686c
leaq 0x1(%r14), %rdi
callq 0x20e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6869
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 0x6875
pushq $-0x3
popq %rbp
leaq 0xaa05(%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_O2/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 0x7143
leaq 0xa14f(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x718f
callq *0x268(%rdi)
andq $0x0, (%rbx)
jmp 0x718f
xorl %edi, %edi
callq 0x59a4
movq %rax, (%rbx)
testq %rax, %rax
je 0x718f
movq 0x40(%rax), %r15
movq %r14, %rdi
callq *0x28(%r14)
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
js 0x712f
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 0x7198
jmp 0x712f
leaq 0xa0e2(%rip), %rax      # 0x11278
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: c_copy
static
size_t c_copy(STRING* self, char** dest)
{
    if (self->empty(self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if ((*dest = (char*)
                malloc(sizeof(char) * (self->size(self) + 1))) == NULL) {
#ifdef  LIBRARY_VERBOSE
        print_error();
/* LIBRARY_VERBOSE */
#endif
        status = EMEMORYALLOC; goto ERR;
    } else {
        memcpy(*dest, self->c_str(self), self->size(self));
        *((*dest) + self->size(self)) = '\0';
    }

    return self->size(self) + 1;

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

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq *0xa0(%rdi)
testl %eax, %eax
je 0x71c6
pushq $-0x4
popq %rax
leaq 0xa0b8(%rip), %rcx      # 0x11278
movl %eax, (%rcx)
cltq
jmp 0x7217
movq %rbx, %rdi
callq *0x18(%rbx)
leaq 0x1(%rax), %rdi
callq 0x20e0
movq %rax, (%r14)
testq %rax, %rax
je 0x7223
movq %rax, %r15
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r12
movq %rbx, %rdi
callq *0x18(%rbx)
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2470
movq (%r14), %r14
movq %rbx, %rdi
callq *0x18(%rbx)
movb $0x0, (%r14,%rax)
movq %rbx, %rdi
callq *0x18(%rbx)
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $-0x3
jmp 0x71b8
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: compare
static
int compare(STRING* self, STRING* opp)
{
    if (opp == NULL)
        return (status = EARGISNULPTR);

    if ((self->size(self) != opp->size(opp)) ||
            (memcmp(self->c_str(self), opp->c_str(opp), self->size(self)) != 0))
        return 1;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x7281
movq %rsi, %r14
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r15
movq %r14, %rdi
callq *0x18(%r14)
cmpq %rax, %r15
jne 0x7292
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r15
movq %r14, %rdi
callq *0xc8(%r14)
movq %rax, %r14
movq %rbx, %rdi
callq *0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x22c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x7295
leaq 0x9ff0(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
jmp 0x7294
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: c_compare
static
int c_compare(STRING* self, const char* s)
{
    if (s == NULL)
        return (status = EARGISNULPTR);

    if ((self->size(self) != strlen(s)) ||
            (memcmp(self->c_str(self), s, self->size(self)) != 0))
        return 1;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x72eb
movq %rsi, %rbx
movq %rdi, %r14
callq *0x18(%rdi)
movq %rax, %r15
movq %rbx, %rdi
callq 0x21b0
cmpq %rax, %r15
jne 0x72fc
movq %r14, %rdi
callq *0xc8(%r14)
movq %rax, %r15
movq %r14, %rdi
callq *0x18(%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x22c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x72ff
leaq 0x9f86(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
jmp 0x72fe
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: casecmp
static
int casecmp(STRING* self, STRING* opp)
{
    int     cmp = 0;

    STRING* s1  = NULL,
          * s2  = NULL;

    if (opp == NULL)
        return (status = EARGISNULPTR);

    if (self->copy(self, &s1) < 0 ||
            opp->copy(opp, &s2) < 0)
        goto ERR;

    s1->downcase(&s1);
    s2->downcase(&s2);
    cmp = s1->compare(s1, s2);
    s1->release(s1);
    s2->release(s2);

    return cmp;

ERR:
    if (s1 != NULL)
        s1->release(s1);
    if (s2 != NULL)
        s2->release(s2);

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
testq %rsi, %rsi
je 0x73b0
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x7386
movq %rsp, %rsi
movq %rbx, %rdi
callq *0xd0(%rbx)
testl %eax, %eax
js 0x7386
leaq 0x8(%rsp), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x190(%rax)
movq %rsp, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x190(%rax)
movq (%r14), %rdi
movq (%r15), %rsi
callq *0x118(%rdi)
movl %eax, %ebx
movq (%r14), %rdi
callq *0x268(%rdi)
movq (%r15), %rdi
callq *0x268(%rdi)
jmp 0x73c0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7396
callq *0x268(%rdi)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x73a5
callq *0x268(%rdi)
leaq 0x9ecc(%rip), %rax      # 0x11278
movl (%rax), %ebx
jmp 0x73c0
leaq 0x9ec1(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: c_casecmp
static
int c_casecmp(STRING* self, char* const s)
{
    int     cmp = 0;

    STRING* s1  = NULL,
          * s2  = NULL;

    if (s == NULL)
        return (status = EARGISNULPTR);

    if (self->copy(self, &s1) < 0 ||
            ((s2 = new_string(s)) == NULL))
        goto ERR;

    s1->downcase(&s1);
    s2->downcase(&s2);
    cmp = s1->compare(s1, s2);
    s1->release(s1);
    s2->release(s2);

    return cmp;

ERR:
    if (s1 != NULL)
        s1->release(s1);
    if (s2 != NULL)
        s2->release(s2);

    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, (%rsp)
testq %rsi, %rsi
je 0x745d
movq %rsi, %rbx
movq %rsp, %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x7443
movq %rbx, %rdi
callq 0x59a4
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x7443
movq %rax, %rbx
movq %rsp, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x190(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x190(%rbx)
movq (%r14), %rdi
movq (%r15), %rsi
callq *0x118(%rdi)
movl %eax, %ebx
movq (%r14), %rdi
callq *0x268(%rdi)
movq (%r15), %rdi
callq *0x268(%rdi)
jmp 0x746d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7452
callq *0x268(%rdi)
leaq 0x9e1f(%rip), %rax      # 0x11278
movl (%rax), %ebx
jmp 0x746d
leaq 0x9e14(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
pushq $-0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq