LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7816
movl $0x1, -0x4(%rbp)
jmp 0x78a7
jmp 0x7818
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x784b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x7854
jmp 0x78a0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x2300
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x7892
movl $0x2, -0x4(%rbp)
jmp 0x78a7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7818
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x1, %eax
movq %rax, -0x98(%rbp)
movl $0x2, -0x10(%rbp)
movl $0x11, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
cmpl $-0x1, %eax
jne 0x78f2
movl $0x1, %edi
callq 0x20c0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x964b
leaq 0xdc08(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x96d3
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
xorl %edi, %edi
leaq 0x8eb3(%rip), %rsi      # 0x1251c
callq 0x23d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x96c9
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x21b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x96aa
leaq 0xdba6(%rip), %rax      # 0x17248
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x96d3
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x966e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x96db
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9715
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rdi
callq 0x2190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x97a9
movl $0x0, -0x4(%rbp)
jmp 0x990a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x982d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x38(%rbp), %rdi
movq %rax, %rdx
subq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2050
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x98f5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0xf100
cmpl $0x0, %eax
jge 0x9855
leaq 0xd9fe(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x98fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movsbl -0x19(%rbp), %eax
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movb -0x39(%rbp), %al
subq %rcx, %rdx
movzbl %al, %esi
callq 0x2050
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x98f5
movl $0x0, -0x4(%rbp)
jmp 0x990a
leaq 0xd943(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9949
leaq 0xd90a(%rip), %rax      # 0x17248
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x9a05
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
shlq $0x0, %rsi
callq 0x23c0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x9999
leaq 0xd8b7(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x9a05
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x99d3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
xorl %esi, %esi
callq 0x2050
jmp 0x99fc
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x9a11
leaq 0xd83c(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x9a57
leaq 0xd7f9(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x9ad3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
shlq $0x0, %rsi
callq 0x23c0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x9aae
leaq 0xd7a2(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x9ad3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x9aca
movl $0x0, -0x4(%rbp)
jmp 0x9adf
leaq 0xd76e(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9b51
leaq 0xd702(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0x9c1e
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x9b79
leaq 0xd6da(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0x9c1e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
cmpq %rcx, %rax
jb 0x9bab
cmpq $0x0, -0x28(%rbp)
jne 0x9bb5
movq $0x0, -0x8(%rbp)
jmp 0x9c2c
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9c14
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2380
cmpl $0x0, %eax
jne 0x9c06
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9c12
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9bca
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c2c
leaq 0xd623(%rip), %rax      # 0x17248
movslq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9c69
leaq 0xd5ea(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0x9d1b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x9c96
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0xf200
cmpl $0x0, %eax
jge 0x9cd9
leaq 0xd577(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x9d1b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
callq 0x2410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x9d46
leaq 0xd526(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $-0x5, %eax
je 0x9d38
jmp 0x9d2e
movl -0x1c(%rbp), %eax
subl $-0x3, %eax
jne 0x9d3a
jmp 0x9d38
jmp 0x9d3a
leaq 0xd507(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9d7d
leaq 0xd4da(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x9dd8
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xf100
cmpl $0x0, %eax
jge 0x9db9
leaq 0xd49e(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x9dd8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9e19
leaq 0xd43a(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0x9ec7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xf100
cmpl $0x0, %eax
jge 0x9e4e
leaq 0xd402(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x9ec7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2410
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x9ef2
leaq 0xd37a(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $-0x5, %eax
je 0x9ee4
jmp 0x9eda
movl -0x34(%rbp), %eax
subl $-0x3, %eax
jne 0x9ee6
jmp 0x9ee4
jmp 0x9ee6
leaq 0xd35b(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x9f27
movl $0x0, -0x4(%rbp)
jmp 0x9fba
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf100
cmpl $0x0, %eax
jge 0x9f49
leaq 0xd307(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x9f9c
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9fba
leaq 0xd2a5(%rip), %rax      # 0x17248
movl (%rax), %eax
subl $-0x3, %eax
jne 0x9fae
jmp 0x9fac
jmp 0x9fae
leaq 0xd293(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xa007
leaq 0xd249(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0xa034
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: swap
static
void swap(STRING** s1, STRING** s2)
{
    STRING*     s3  = NULL;

    s3 = *s1;
    *s1 = *s2;
    *s2 = s3;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa0ad
leaq 0xd1a6(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0xa1e2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
jne 0xa0d4
leaq 0xd17f(%rip), %rax      # 0x17248
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xa1e2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2190
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xf100
cmpl $0x0, %eax
jge 0xa10c
leaq 0xd147(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0xa1e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
addq -0x18(%rbp), %rdi
callq 0x2190
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x2310
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0xa217
leaq 0xd05f(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x54(%rbp)
subl $-0x5, %eax
je 0xa209
jmp 0xa1f5
movl -0x54(%rbp), %eax
subl $-0x3, %eax
je 0xa209
jmp 0xa1ff
movl -0x54(%rbp), %eax
subl $-0x1, %eax
jne 0xa20b
jmp 0xa209
jmp 0xa20b
leaq 0xd036(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
je 0xa262
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
jne 0xa274
leaq 0xcfdf(%rip), %rax      # 0x17248
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xa349
cmpq $0x0, -0x20(%rbp)
jne 0xa297
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
addq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x2190
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2310
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq 0x8(%rax), %rdi
xorl %eax, %eax
subq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x2050
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rdi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa367
leaq 0xcef8(%rip), %rax      # 0x17248
movl (%rax), %eax
subl $-0x1, %eax
jne 0xa35b
jmp 0xa359
jmp 0xa35b
leaq 0xcee6(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa3a5
leaq 0xceb2(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xa40a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jge 0xa3d4
leaq 0xce7b(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa40a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jge 0xa403
leaq 0xce4c(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa40a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa45a
cmpq $0x0, -0x20(%rbp)
jne 0xa473
leaq 0xcde7(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xa56f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0xa4a2
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xa4bb
leaq 0xcd9f(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xa56f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xa501
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2380
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa50a
jmp 0xa524
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa4d6
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa552
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
jmp 0xa568
leaq 0xccef(%rip), %rax      # 0x17248
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0xa56f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xa5c7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa59b
leaq 0xcc7a(%rip), %rax      # 0x17248
cmpl $-0x4, (%rax)
je 0xa5df
leaq 0xcc6e(%rip), %rax      # 0x17248
cmpl $-0x6, (%rax)
jne 0xa5f2
cmpl $0x0, -0x1c(%rbp)
je 0xa5f2
leaq 0xcc5c(%rip), %rax      # 0x17248
movl $0x0, (%rax)
leaq 0xcc4f(%rip), %rax      # 0x17248
movl (%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
jne 0xa645
leaq 0xcc0b(%rip), %rax      # 0x17248
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xa661
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movb -0x1(%rax,%rcx), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: front
static
char* front(STRING* self)
{
    if (self->empty(self)) {
        status = ESTRISEMPTY;

        return NULL;
    }

    return self->c_str(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xa6d9
leaq 0xcb7f(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, -0x8(%rbp)
jmp 0xa6ee
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xa739
leaq 0xcb1f(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, -0x8(%rbp)
jmp 0xa76e
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa9c5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
je 0xa9ed
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0xf2a0
cmpl $0x0, %eax
jne 0xa9fc
leaq 0xc854(%rip), %rax      # 0x17248
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xaa71
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaa29
leaq 0xc827(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0xaa71
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2410
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0xaa9f
leaq 0xc7d0(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x34(%rbp)
addl $0x4, %eax
subl $0x2, %eax
jb 0xaa91
jmp 0xaa87
movl -0x34(%rbp), %eax
subl $-0x1, %eax
jne 0xaa93
jmp 0xaa91
jmp 0xaa93
leaq 0xc7ae(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xb9a8
leaq 0xb8ab(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0xba45
xorl %eax, %eax
movl %eax, %edi
callq 0x8fd0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb9c3
jmp 0xba45
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rsi
callq *%rax
cmpl $0x0, %eax
jge 0xba00
jmp 0xba45
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
callq *%rax
cmpl $0x0, %eax
jge 0xba3c
jmp 0xba45
movl $0x0, -0x4(%rbp)
jmp 0xba7d
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xba71
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
leaq 0xb7d0(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xbac8
leaq 0xb78b(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
jmp 0xbb7c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xbb02
leaq 0xb74e(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0xbb7c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2410
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xbb9f
leaq 0xb6c5(%rip), %rax      # 0x17248
movl (%rax), %eax
addl $0x4, %eax
subl $0x1, %eax
ja 0xbb91
jmp 0xbb8f
jmp 0xbb91
leaq 0xb6b0(%rip), %rax      # 0x17248
movslq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbbe0
leaq 0xb67a(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xbc69
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0xbc59
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2380
cmpl $0x0, %eax
je 0xbc62
movl $0x1, -0x4(%rbp)
jmp 0xbc69
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbcad
leaq 0xb5aa(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xbd24
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0xbd14
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2380
cmpl $0x0, %eax
je 0xbd1d
movl $0x1, -0x4(%rbp)
jmp 0xbd24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbd77
leaq 0xb4e3(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xbe47
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jl 0xbdab
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0xbdad
jmp 0xbe0b
movq -0x28(%rbp), %rax
leaq -0x28(%rbp), %rdi
callq *0x190(%rax)
movq -0x30(%rbp), %rax
leaq -0x30(%rbp), %rdi
callq *0x190(%rax)
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x268(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rax
movq 0x268(%rax), %rax
movq -0x30(%rbp), %rdi
callq *%rax
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbe47
cmpq $0x0, -0x28(%rbp)
je 0xbe23
movq -0x28(%rbp), %rax
movq 0x268(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
cmpq $0x0, -0x30(%rbp)
je 0xbe3b
movq -0x30(%rbp), %rax
movq 0x268(%rax), %rax
movq -0x30(%rbp), %rdi
callq *%rax
leaq 0xb406(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq