LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x5657
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 0x5659
incq %rbx
movslq 0x8(%r15), %rax
addq $0x8, %r12
cmpq %rax, %rbx
jl 0x562d
jmp 0x5659
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/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 0x56ca
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 0x56a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/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 0x5728
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 0x572b
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x5708
xorl %eax, %eax
jmp 0x5730
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5796
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x5787
cmpl $0x0, 0x8(%rbx)
jle 0x5778
xorl %eax, %eax
movq (%rbx), %rcx
movslq %eax, %r14
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x5773
callq *0x68(%rdi)
movq (%rbx), %rax
movq $0x0, (%rax,%r14,8)
incl %r14d
movl %r14d, %eax
cmpl 0x8(%rbx), %eax
jl 0x5750
movq (%rbx), %rdi
callq 0x21a0
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57ec
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testl %eax, %eax
js 0x57da
movq 0x8(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x57cd
callq 0x21a0
movq 0x8(%rbx), %rax
movslq 0x4(%rbx), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x4(%rbx), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x4(%rbx)
testl %ecx, %ecx
jg 0x57a9
movq 0x8(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x5844
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x582d
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 0x580a
movq %rax, %rdi
callq 0x21a0
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5894
movq %rdi, %r14
movl (%rdi), %edi
xorl %ebx, %ebx
testl %edi, %edi
je 0x58a0
addq $0x10, %r14
movq -0x8(%r14), %rsi
testq %rsi, %rsi
je 0x58a0
callq 0x2330
cmpq $-0x1, %rax
je 0x589b
movl (%r14), %edi
addq $0x10, %r14
testl %edi, %edi
jne 0x5873
jmp 0x58a0
movl $0x1, %ebx
jmp 0x58a0
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58de
addq $0x98, %rsp
retq
movl $0x1, %edi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O1/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 0x6a50
leaq 0xa82f(%rip), %rax      # 0x11270
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 0x595d(%rip), %rsi      # 0xc3c0
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2420
cmpb $0x0, (%r14)
je 0x6a45
xorl %ebx, %ebx
callq 0x21d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2310
testl %eax, %eax
js 0x6a9a
movl %eax, %eax
incq %rbx
cmpb $0x0, (%r14,%rax)
leaq (%r14,%rax), %r14
jne 0x6a74
jmp 0x6a45
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x6a3a
// File: /workspace/github_c_makefile_star2_O1/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
testq %rsi, %rsi
je 0x6ab0
movq (%rbx), %rax
movq %rsi, (%rax)
movq (%rbx), %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_O1/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 0x6b66
movq (%r14), %rdi
callq *0x18(%rdi)
cmpq %r15, %rax
jbe 0x6b15
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 0x6b56
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9d01
testl %eax, %eax
js 0x6b71
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 0xa6f8(%rip), %rax      # 0x11270
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x6b66
// File: /workspace/github_c_makefile_star2_O1/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 0x6bd4
movq %rsi, %rbx
movq %rdi, %r14
incq %rsi
movq (%rdi), %rax
movq %rsi, (%rax)
movq 0x10(%rax), %rdi
callq 0x2410
movq (%r14), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x6bdb
movq (%r14), %rdi
callq *0xa0(%rdi)
movq (%r14), %rcx
testl %eax, %eax
je 0x6bf3
movq (%rcx), %rdx
movq 0x10(%rcx), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2050
jmp 0x6be9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x6be0
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
leaq 0xa689(%rip), %rax      # 0x11270
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 0x6be9
// File: /workspace/github_c_makefile_star2_O1/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 0x6c26
leaq 0xa64e(%rip), %rcx      # 0x11270
movl %eax, (%rcx)
jmp 0x6c59
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
incq %rsi
movq %rsi, (%rax)
callq 0x2410
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x6c5b
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 0x6c1b
// File: /workspace/github_c_makefile_star2_O1/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 0x6ceb
movq %rsi, %rbx
movq %rdi, %r15
callq *0xa0(%rdi)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x6cf0
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
decq %rax
cmpq %r12, %rax
jae 0x6d0b
movq %r15, %rdi
callq *0xc8(%r15)
cmpb $0x0, (%rax)
je 0x6d0b
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 0x6cd9
movl $0x1, %edx
movb %al, %cl
addq %rcx, %r15
cmpb $0x0, (%r12,%rdx)
leaq (%r12,%rdx), %r12
jne 0x6cba
jmp 0x6cfc
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
leaq 0xa579(%rip), %rax      # 0x11270
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 0x6cfc
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6daf
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x6d43
callq 0x21a0
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x21b0
movq (%rbx), %r12
movq %rax, 0x8(%r12)
incq %rax
movq (%r12), %rdi
cmpq %rax, %rdi
jae 0x6d8a
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, (%r12)
callq 0x20e0
movq %rax, %r15
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x6db6
movq (%rbx), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x2050
jmp 0x6dc3
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6df3
leaq 0xa4b3(%rip), %rax      # 0x11270
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
testq %r15, %r15
je 0x6dee
movq (%rbx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x2460
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
jmp 0x6dfc
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
leaq 0xa476(%rip), %rcx      # 0x11270
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/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 0x6e4a
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x9d01
testl %eax, %eax
js 0x6e5e
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 0xa41f(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6e70
leaq 0xa40b(%rip), %rax      # 0x11270
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ee0
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x9d01
testl %eax, %eax
js 0x6ee7
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 0x2460
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 0x6ef5
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6eec
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
leaq 0xa37d(%rip), %rcx      # 0x11270
movl %eax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6f53
movq %rdi, %r14
movl $0x2, %esi
callq 0x9d01
testl %eax, %eax
js 0x6f41
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 0x6f53
leaq 0xa328(%rip), %rax      # 0x11270
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_O1/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 0x6f7a
leaq 0xa2fe(%rip), %rax      # 0x11270
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x6f92
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_O1/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 0x704f
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x18(%rdi)
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
jb 0x705b
movq %r14, %rdi
callq 0x21b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x9d01
testl %eax, %eax
js 0x7056
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 0x2460
movq (%rbx), %r14
movq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
jmp 0x7064
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x705b
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
leaq 0xa20e(%rip), %rcx      # 0x11270
movl %eax, (%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7099
movq (%rbx), %rdi
leaq (%r14,%r15), %r12
callq *0x18(%rdi)
cmpq %r12, %rax
jae 0x70ad
leaq 0xa1d0(%rip), %rax      # 0x11270
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x7111
testq %r14, %r14
jne 0x70be
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_O1/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 0x715c
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x90(%rax)
testl %eax, %eax
js 0x7170
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x88(%rax)
leaq 0xa11b(%rip), %rcx      # 0x11270
sarl $0x1f, %eax
andl (%rcx), %eax
jmp 0x7179
leaq 0xa10d(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x7179
leaq 0xa0f9(%rip), %rax      # 0x11270
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x71ae
leaq 0xa0cf(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x71d6
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x71e5
leaq 0xa0a5(%rip), %rax      # 0x11270
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
movq %rax, (%rsp)
testq %rax, %rax
je 0x71c4
movq (%r14), %rdi
callq *0xc8(%rdi)
cmpb $0x0, (%rax)
sete %r12b
je 0x7251
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
callq 0x22c0
testl %eax, %eax
je 0x724a
incq %r13
xorl %ebp, %ebp
cmpb $0x0, (%r13,%rbp)
sete %r12b
je 0x7251
movq %r13, %rdi
addq %rbp, %rdi
incq %rbp
movq %r15, %rsi
movq (%rsp), %rdx
callq 0x22c0
testl %eax, %eax
jne 0x7223
jmp 0x724c
xorl %ebp, %ebp
testb %r12b, %r12b
je 0x7268
leaq 0xa018(%rip), %rax      # 0x11270
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x71d6
movq (%r14), %rax
movq %r14, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
callq *0x98(%rax)
xorl %eax, %eax
jmp 0x71d6
// File: /workspace/github_c_makefile_star2_O1/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 0x729a
leaq 0x9fb7(%rip), %rax      # 0x11270
movl (%rax), %ecx
addl $0x6, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
sete %cl
testl %ebp, %ebp
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x72d9
movl $0x0, (%rax)
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7309
leaq 0x9f71(%rip), %rax      # 0x11270
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x7317
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_O1/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 0x737a
leaq 0x9f00(%rip), %rax      # 0x11270
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %eax, %eax
jmp 0x7392
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_O1/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 0x73c6
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r12
subq %r14, %r12
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r14, %rax
jb 0x73e2
leaq (%r12,%r14), %r13
movq %r15, %rdi
callq *0x18(%r15)
cmpq %r13, %rax
jae 0x7402
leaq 0x9e87(%rip), %rax      # 0x11270
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x9e7a(%rip), %rax      # 0x11270
movl (%rax), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x65a4
movq %rax, (%rbx)
testq %rax, %rax
je 0x746b
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 0x746b
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 0x2460
movq (%rbx), %rdi
movq 0x10(%rdi), %rbx
callq *0x18(%rdi)
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
jmp 0x73f8
leaq 0x9dfe(%rip), %rax      # 0x11270
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x73ef
callq *0x268(%rdi)
movq $0x0, (%rbx)
jmp 0x73ef
// File: /workspace/github_c_makefile_star2_O1/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 0x74c0
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 0x7524
leaq (%r14,%r15), %r13
movq %r12, %rdi
callq *0x18(%r12)
cmpq %r13, %rax
jb 0x7524
leaq 0x1(%r14), %rdi
callq 0x20e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x751f
movq %rax, %r13
movq %r12, %rdi
callq *0xc8(%r12)
addq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2460
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
xorl %ebp, %ebp
jmp 0x752d
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
leaq 0x9d45(%rip), %rax      # 0x11270
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_O1/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 0x7e76
leaq 0x9424(%rip), %rax      # 0x11270
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e67
callq *0x268(%rdi)
movq $0x0, (%rbx)
leaq 0x9402(%rip), %rax      # 0x11270
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x65a4
movq %rax, (%rbx)
testq %rax, %rax
je 0x7e52
movq 0x40(%rax), %r15
movq %r14, %rdi
callq *0x28(%r14)
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
js 0x7e52
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 0x7e70
jmp 0x7e52
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x7eed
leaq 0x938a(%rip), %rax      # 0x11270
movl %ecx, (%rax)
movslq %ecx, %rax
jmp 0x7f3e
movq %rbx, %rdi
callq *0x18(%rbx)
leaq 0x1(%rax), %rdi
callq 0x20e0
movq %rax, (%r14)
testq %rax, %rax
je 0x7f4a
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 0x2460
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
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jmp 0x7edf
// File: /workspace/github_c_makefile_star2_O1/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 0x7fb3
movq %rsi, %r14
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r15
movq %r14, %rdi
callq *0x18(%r14)
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %r15
jne 0x7fc5
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 0x7fc5
leaq 0x92b6(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8023
movq %rsi, %rbx
movq %rdi, %r14
callq *0x18(%rdi)
movq %rax, %r15
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %r15
jne 0x8035
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 0x8035
leaq 0x9246(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x80e6
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x80bc
movq %rsp, %rsi
movq %rbx, %rdi
callq *0xd0(%rbx)
testl %eax, %eax
js 0x80bc
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 0x80f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x80cc
callq *0x268(%rdi)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x80db
callq *0x268(%rdi)
leaq 0x918e(%rip), %rax      # 0x11270
movl (%rax), %ebx
jmp 0x80f8
leaq 0x9183(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x81b0
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x8186
movq %rbx, %rdi
callq 0x65a4
movq %rax, (%rsp)
testq %rax, %rax
je 0x8186
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 0x81c2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8196
callq *0x268(%rdi)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x81a5
callq *0x268(%rdi)
leaq 0x90c4(%rip), %rax      # 0x11270
movl (%rax), %ebx
jmp 0x81c2
leaq 0x90b9(%rip), %rax      # 0x11270
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: concat
static
int concat(STRING** self, STRING* opp, ...)
{
    STRING* p   = NULL;

    va_list list;

    va_start(list, opp);
    p = opp;
    while (p != NULL) {
        if ((*self)->append(self, p->c_str(p)) < 0)
            goto ERR;
        p = va_arg(list, STRING*);
    }
    va_end(list);

    return 0;

ERR:
    va_end(list);

    return status;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x822b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x8299
movq (%rbx), %rax
movq 0x68(%rax), %r14
movq %rsi, %rdi
callq *0xc8(%rsi)
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
testl %eax, %eax
js 0x829d
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x8286
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x8294
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
jmp 0x824b
xorl %eax, %eax
jmp 0x82a6
leaq 0x8fcc(%rip), %rax      # 0x11270
movl (%rax), %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: c_concat
static
int c_concat(STRING** self, char* const s, ...)
{
    char*   p   = NULL;

    va_list list;

    va_start(list, s);
    p = s;
    while (p != NULL) {
        if ((*self)->append(self, p) < 0)
            goto ERR;
        p = va_arg(list, char* const);
    }
    va_end(list);

    return 0;

ERR:
    va_end(list);

    return status;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x830c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x836a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
testl %eax, %eax
js 0x836e
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x8357
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x8365
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
jmp 0x832c
xorl %eax, %eax
jmp 0x8377
leaq 0x8efb(%rip), %rax      # 0x11270
movl (%rax), %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: chomp
static
size_t chomp(STRING** self)
{
    size_t  n   = 0;

    char*   p   = NULL;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY;
        return 0;
    }
    p = (*self)->c_str(*self) + (*self)->size(*self) - 1;
    while ((*self)->size(*self) > 0 &&
            (*p == '\r' || *p == '\n')) {
        *p = '\0';
        p--;
        (*self)->length--;
        n++;
    }

    return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x83ae
leaq 0x8ed4(%rip), %rax      # 0x11270
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %r14
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r15
movq (%rbx), %rdi
callq *0x18(%rdi)
testq %rax, %rax
je 0x83a2
addq %r14, %r15
decq %r15
xorl %r14d, %r14d
movzbl (%r15), %eax
cmpl $0xd, %eax
je 0x83e5
cmpl $0xa, %eax
jne 0x83a5
movb $0x0, (%r15)
movq (%rbx), %rdi
decq 0x8(%rdi)
incq %r14
callq *0x18(%rdi)
decq %r15
testq %rax, %rax
jne 0x83d7
jmp 0x83a5
// File: /workspace/github_c_makefile_star2_O1/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: lstrip
static
size_t lstrip(STRING** self)
{
    size_t  n   = 0;

    char*   p   = NULL;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY;
        return 0;
    }
    p = (*self)->c_str(*self);
    while (*p != '\0' &&
            (*p == '\t' || *p == '\n' || *p == '\v' ||
             *p == '\f' || *p == '\r' || *p == ' ')) {
        p++;
        n++;
    }
    p = (*self)->c_str(*self);
    if (n > 0) {
        memmove(p, p + n, (*self)->size(*self) - n);
        memset(p + (*self)->size(*self) - n, '\0', n);
        (*self)->length -= n;
    }

    return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x842a
leaq 0x8e51(%rip), %rax      # 0x11270
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %r14d, %r14d
jmp 0x849a
movq (%rbx), %rdi
callq *0xc8(%rdi)
xorl %r14d, %r14d
movzbl (%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x8449
incq %rax
incq %r14
jmp 0x8436
cmpl $0x20, %ecx
je 0x8441
movq (%rbx), %rdi
callq *0xc8(%rdi)
testq %r14, %r14
je 0x849a
movq %rax, %r15
leaq (%rax,%r14), %r12
movq (%rbx), %rdi
callq *0x18(%rdi)
subq %r14, %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2340
movq (%rbx), %rdi
callq *0x18(%rdi)
addq %rax, %r15
subq %r14, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2050
movq (%rbx), %rax
subq %r14, 0x8(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq