LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x7dbf
leaq 0x94c0(%rip), %rax      # 0x11278
movl %ecx, (%rax)
movslq %ecx, %rax
jmp 0x7e10
movq %rbx, %rdi
callq *0x18(%rbx)
leaq 0x1(%rax), %rdi
callq 0x20e0
movq %rax, (%r14)
testq %rax, %rax
je 0x7e1c
movq %rax, %r15
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r12
movq %rbx, %rdi
callq *0x18(%rbx)
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2470
movq (%r14), %r14
movq %rbx, %rdi
callq *0x18(%rbx)
movb $0x0, (%r14,%rax)
movq %rbx, %rdi
callq *0x18(%rbx)
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jmp 0x7db1
// File: /workspace/github_c_makefile_star2_O3/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 0x7e85
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 0x7e97
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 0x7e97
leaq 0x93ec(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7ef5
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 0x7f07
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 0x7f07
leaq 0x937c(%rip), %rax      # 0x11278
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7fb8
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x7f8e
movq %rsp, %rsi
movq %rbx, %rdi
callq *0xd0(%rbx)
testl %eax, %eax
js 0x7f8e
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 0x7fca
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7f9e
callq *0x268(%rdi)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7fad
callq *0x268(%rdi)
leaq 0x92c4(%rip), %rax      # 0x11278
movl (%rax), %ebx
jmp 0x7fca
leaq 0x92b9(%rip), %rax      # 0x11278
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_O3/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
movq $0x0, (%rsp)
testq %rsi, %rsi
je 0x806a
movq %rsi, %rbx
movq %rsp, %rsi
callq *0xd0(%rdi)
testl %eax, %eax
js 0x8050
movq %rbx, %rdi
callq 0x6460
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x8050
movq %rax, %rbx
movq %rsp, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x190(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x190(%rbx)
movq (%r14), %rdi
movq (%r15), %rsi
callq *0x118(%rdi)
movl %eax, %ebx
movq (%r14), %rdi
callq *0x268(%rdi)
movq (%r15), %rdi
callq *0x268(%rdi)
jmp 0x807c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x805f
callq *0x268(%rdi)
leaq 0x9212(%rip), %rax      # 0x11278
movl (%rax), %ebx
jmp 0x807c
leaq 0x9207(%rip), %rax      # 0x11278
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_O3/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 0x80e5
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 0x8153
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 0x8157
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x8140
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x814e
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
jmp 0x8105
xorl %eax, %eax
jmp 0x8160
leaq 0x911a(%rip), %rax      # 0x11278
movl (%rax), %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x81c6
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 0x8224
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
testl %eax, %eax
js 0x8228
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x8211
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x821f
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
jmp 0x81e6
xorl %eax, %eax
jmp 0x8231
leaq 0x9049(%rip), %rax      # 0x11278
movl (%rax), %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8268
leaq 0x9022(%rip), %rax      # 0x11278
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 0x825c
addq %r14, %r15
decq %r15
xorl %r14d, %r14d
movzbl (%r15), %eax
cmpl $0xd, %eax
je 0x829f
cmpl $0xa, %eax
jne 0x825f
movb $0x0, (%r15)
movq (%rbx), %rdi
decq 0x8(%rdi)
incq %r14
callq *0x18(%rdi)
decq %r15
testq %rax, %rax
jne 0x8291
jmp 0x825f
// File: /workspace/github_c_makefile_star2_O3/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 0x82e4
leaq 0x8f9f(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
xorl %r14d, %r14d
jmp 0x8354
movq (%rbx), %rdi
callq *0xc8(%rdi)
xorl %r14d, %r14d
movzbl (%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x8303
incq %rax
incq %r14
jmp 0x82f0
cmpl $0x20, %ecx
je 0x82fb
movq (%rbx), %rdi
callq *0xc8(%rdi)
testq %r14, %r14
je 0x82df
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
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: rstrip
static
size_t rstrip(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 == '\t' || *p == '\n' || *p == '\v' ||
             *p == '\f' || *p == '\r' || *p == ' ')) {
        *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 0x8391
leaq 0x8ef9(%rip), %rax      # 0x11278
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 0x8385
addq %r14, %r15
decq %r15
xorl %r14d, %r14d
movzbl (%r15), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x83e1
movb $0x0, (%r15)
movq (%rbx), %rdi
decq 0x8(%rdi)
incq %r14
callq *0x18(%rdi)
decq %r15
testq %rax, %rax
jne 0x83ba
jmp 0x8388
cmpl $0x20, %eax
je 0x83c6
jmp 0x8388
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: rjust
static
int rjust(STRING** self, size_t s, char c)
{
    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if ((*self)->size(*self) >= s)
        return 0;

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

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x841b
leaq 0x8e64(%rip), %rax      # 0x11278
movl %ebx, (%rax)
jmp 0x84bc
movq (%r15), %rdi
callq *0x18(%rdi)
xorl %ebx, %ebx
cmpq %r14, %rax
jae 0x84bc
leaq 0x1(%r14), %rsi
movq %r15, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x84cd
testb %bpl, %bpl
movzbl %bpl, %eax
movl $0x20, %ebp
cmovnel %eax, %ebp
movq (%r15), %rdi
callq *0xc8(%rdi)
leaq (%rax,%r14), %r12
movq (%r15), %rdi
callq *0x18(%rdi)
subq %rax, %r12
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%r15), %rdi
callq *0x18(%rdi)
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2340
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %r12
movq (%r15), %rdi
callq *0x18(%rdi)
movq %r14, %rdx
subq %rax, %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0x2050
movq (%r15), %rdi
callq *0xc8(%rdi)
movb $0x0, (%rax,%r14)
movq (%r15), %rax
movq %r14, 0x8(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x840d
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: ljust
static
int ljust(STRING** self, size_t s, char c)
{
    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if ((*self)->size(*self) >= s)
        return 0;

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

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x8504
leaq 0x8d78(%rip), %rax      # 0x11278
movl %ebx, (%rax)
jmp 0x8570
movq (%r15), %rdi
callq *0x18(%rdi)
xorl %ebx, %ebx
cmpq %r14, %rax
jae 0x8570
leaq 0x1(%r14), %rsi
movq %r15, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x857b
testb %bpl, %bpl
movzbl %bpl, %eax
movl $0x20, %ebp
cmovnel %eax, %ebp
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %r12
movq (%r15), %rdi
callq *0x18(%rdi)
addq %rax, %r12
movq (%r15), %rdi
callq *0x18(%rdi)
movq %r14, %rdx
subq %rax, %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0x2050
movq (%r15), %rdi
callq *0xc8(%rdi)
movb $0x0, (%rax,%r14)
movq (%r15), %rax
movq %r14, 0x8(%rax)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x84f9
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: center
static
int center(STRING** self, size_t s, char c)
{
    size_t  s2  = 0;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if ((*self)->size(*self) >= s)
        return 0;

    if (c == '\0')
        c = ' ';
    s2 = (s - (*self)->size(*self)) >> 1;
    if (reallocate_memory(self, s + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memmove((*self)->c_str(*self) + s2,
                (*self)->c_str(*self),
                (*self)->size(*self));
        memset((*self)->c_str(*self), c, s2);
        memset((*self)->c_str(*self) + (*self)->size(*self) + s2,
                c,
                s2 + (s - (*self)->size(*self)) % 2);
        *((*self)->c_str(*self) + s) = '\0';
        (*self)->length = s;
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x85b8
leaq 0x8cc7(%rip), %rax      # 0x11278
movl %ebx, (%rax)
jmp 0x8691
movq (%r15), %rdi
callq *0x18(%rdi)
xorl %ebx, %ebx
cmpq %r14, %rax
jae 0x8691
movq (%r15), %rdi
callq *0x18(%rdi)
movq %rax, %r13
leaq 0x1(%r14), %rsi
movq %r15, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x86a2
movq %r14, %r12
subq %r13, %r12
shrq %r12
testb %bpl, %bpl
movzbl %bpl, %eax
movl $0x20, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x4(%rsp)
movq (%r15), %rdi
callq *0xc8(%rdi)
leaq (%rax,%r12), %r13
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %rbp
movq (%r15), %rdi
callq *0x18(%rdi)
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2340
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %rdi
movl 0x4(%rsp), %ebp
movl %ebp, %esi
movq %r12, %rdx
callq 0x2050
movq (%r15), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%r15), %rdi
callq *0x18(%rdi)
addq %rax, %r13
addq %r12, %r13
movq (%r15), %rdi
callq *0x18(%rdi)
movl %r14d, %edx
subl %eax, %edx
andl $0x1, %edx
addq %r12, %rdx
movq %r13, %rdi
movl %ebp, %esi
callq 0x2050
movq (%r15), %rdi
callq *0xc8(%rdi)
movb $0x0, (%rax,%r14)
movq (%r15), %rax
movq %r14, 0x8(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x85aa
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbrjust
static
int mbrjust(STRING** self, size_t s, char c)
{
    size_t  s2  = 0;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if (count_mb_witdh(*self, &s2) < 0)
        return (status = EINVALIDCHAR);
    if (s <= s2)
        return 0;
    else
        s2 = s - s2;

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

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq $0x0, (%rsp)
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x86f3
leaq 0x8b98(%rip), %rax      # 0x11278
movl %ebx, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq %rsp, %rsi
callq 0x9c81
testl %eax, %eax
js 0x8789
xorl %ebx, %ebx
movq %r12, %r15
subq (%rsp), %r15
jbe 0x86e2
leaq (%r12,%r15), %rsi
incq %rsi
movq %r14, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x87a0
movq (%r14), %rdi
callq *0xc8(%rdi)
leaq (%rax,%r15), %r12
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%r14), %rdi
callq *0x18(%rdi)
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2340
movq (%r14), %rdi
callq *0xc8(%rdi)
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2050
movq (%r14), %rdi
addq %r15, 0x8(%rdi)
callq *0xc8(%rdi)
movq %rax, %r15
movq (%r14), %rdi
callq *0x18(%rdi)
movb $0x0, (%r15,%rax)
jmp 0x86e2
leaq 0x8ae8(%rip), %rax      # 0x11278
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x86e2
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x86d9
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbljust
static
int mbljust(STRING** self, size_t s, char c)
{
    size_t  s2  = 0;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if (count_mb_witdh(*self, &s2) < 0)
        return (status = EINVALIDCHAR);
    if (s <= s2)
        return 0;
    else
        s2 = s - s2;

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

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x87f1
leaq 0x8a98(%rip), %rax      # 0x11278
movl %ebx, (%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9c81
testl %eax, %eax
js 0x8872
xorl %ebx, %ebx
movq %r12, %r15
subq 0x8(%rsp), %r15
jbe 0x87e2
leaq (%r12,%r15), %rsi
incq %rsi
movq %r14, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x8889
testb %bpl, %bpl
movzbl %bpl, %eax
movl $0x20, %ebp
cmovnel %eax, %ebp
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %r12
movq (%r14), %rdi
callq *0x18(%rdi)
addq %rax, %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x2050
movq (%r14), %rdi
addq %r15, 0x8(%rdi)
callq *0xc8(%rdi)
movq %rax, %r15
movq (%r14), %rdi
callq *0x18(%rdi)
movb $0x0, (%r15,%rax)
jmp 0x87e2
leaq 0x89ff(%rip), %rax      # 0x11278
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x87e2
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x87d9
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbcenter
static
int mbcenter(STRING** self, size_t s, char c)
{
    size_t  ps  = 0,
            s2  = 0;

    if ((*self)->empty(*self)) {
        status = ESTRISEMPTY; goto ERR;
    }
    if (count_mb_witdh(*self, &s2) < 0)
        return (status = EINVALIDCHAR);
    if (s <= s2)
        return 0;

    ps = s2;
    s2 = (s - s2) >> 1;
    if (c == '\0')
        c = ' ';
    if (reallocate_memory(self, s + (s - s2) + 1) < 0) {
        status = EMEMORYALLOC; goto ERR;
    } else {
        memmove((*self)->c_str(*self) + s2,
                (*self)->c_str(*self),
                (*self)->size(*self));
        memset((*self)->c_str(*self), c, s2);
        memset((*self)->c_str(*self) + (*self)->size(*self) + s2,
                c,
                s2 + (s - ps) % 2);
        (*self)->length = strlen((*self)->c_str(*self));
        *((*self)->c_str(*self) + (*self)->size(*self)) = '\0';
    }

    return 0;

ERR:
    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
callq *0xa0(%rdi)
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
testl %eax, %eax
je 0x88de
leaq 0x89ad(%rip), %rax      # 0x11278
movl %ebx, (%rax)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9c81
testl %eax, %eax
js 0x89d5
xorl %ebx, %ebx
movq %r13, %r15
subq 0x8(%rsp), %r15
jbe 0x88cd
movq %r15, %r12
shrq %r12
leaq 0x1(,%r13,2), %rsi
subq %r12, %rsi
movq %r14, %rdi
callq 0x9b9c
testl %eax, %eax
js 0x89ec
testb %bpl, %bpl
movzbl %bpl, %eax
movl $0x20, %ebp
cmovnel %eax, %ebp
movq (%r14), %rdi
callq *0xc8(%rdi)
addq %r12, %rax
movq %rax, 0x10(%rsp)
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%r14), %rdi
callq *0x18(%rdi)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2340
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x2050
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%r14), %rdi
callq *0x18(%rdi)
addq %rax, %r13
addq %r12, %r13
andl $0x1, %r15d
addq %r12, %r15
movq %r13, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x2050
movq (%r14), %rdi
callq *0xc8(%rdi)
movq %rax, %rdi
callq 0x21b0
movq (%r14), %rdi
movq %rax, 0x8(%rdi)
callq *0xc8(%rdi)
movq %rax, %r15
movq (%r14), %rdi
callq *0x18(%rdi)
movb $0x0, (%r15,%rax)
jmp 0x88cd
leaq 0x889c(%rip), %rax      # 0x11278
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x88cd
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x88c4
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: downcase
static
int downcase(STRING** self)
{
    char*   p   = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);

    p = (*self)->c_str(*self);
    while (*p != '\0') {
        if (isupper(*p))
            *p = tolower(*p);
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x8a22
leaq 0x8863(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
jmp 0x8a6d
movq (%rbx), %rdi
callq *0xc8(%rdi)
movb (%rax), %bpl
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x8a6d
movq %rax, %r14
callq 0x21e0
movq %rax, %r15
incq %r14
movq (%r15), %rax
movsbq %bpl, %r12
testb $0x1, 0x1(%rax,%r12,2)
je 0x8a62
callq 0x23c0
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, -0x1(%r14)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x8a43
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: swapcase
static
int swapcase(STRING** self)
{
    char*   p   = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);

    p = (*self)->c_str(*self);
    while (*p != '\0') {
        if (isupper(*p))
            *p = tolower(*p);
        else if (islower(*p))
            *p = toupper(*p);
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x8aa4
leaq 0x87e1(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
jmp 0x8aff
movq (%rbx), %rdi
callq *0xc8(%rdi)
movb (%rax), %bpl
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x8aff
movq %rax, %r14
callq 0x21e0
movq %rax, %r15
incq %r14
movq (%r15), %rax
movsbq %bpl, %r12
movzwl (%rax,%r12,2), %eax
btl $0x8, %eax
jb 0x8ae4
btl $0x9, %eax
jae 0x8af4
callq 0x2170
jmp 0x8ae9
callq 0x23c0
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, -0x1(%r14)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x8ac5
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: upcase
static
int upcase(STRING** self)
{
    char*   p   = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);

    p = (*self)->c_str(*self);
    while (*p != '\0') {
        if (islower(*p))
            *p = toupper(*p);
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x8b36
leaq 0x874f(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
jmp 0x8b81
movq (%rbx), %rdi
callq *0xc8(%rdi)
movb (%rax), %bpl
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x8b81
movq %rax, %r14
callq 0x21e0
movq %rax, %r15
incq %r14
movq (%r15), %rax
movsbq %bpl, %r12
testb $0x2, 0x1(%rax,%r12,2)
je 0x8b76
callq 0x2170
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, -0x1(%r14)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x8b57
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: capitalize
static
int capitalize(STRING** self)
{
    char*   p               = NULL;

    int     (*f1)(int c)    = isascii,
            (*f2)(int c)    = toupper;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);

    p = (*self)->c_str(*self);
    while (*p != '\0') {
        if (f1(*p)) {
            *p = f2(*p);
            f1 = isascii;
            f2 = tolower;
        }
        p++;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x8bb5
leaq 0x86d0(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
jmp 0x8bf4
movq (%rbx), %rdi
callq *0xc8(%rdi)
movb (%rax), %cl
xorl %ebx, %ebx
testb %cl, %cl
je 0x8bf4
movq %rax, %r14
incq %r14
movq 0x83c5(%rip), %rax      # 0x10f98
movq 0x83f6(%rip), %r15      # 0x10fd0
testb %cl, %cl
js 0x8bea
movzbl %cl, %edi
callq *%rax
movb %al, -0x1(%r14)
movq %r15, %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x8bda
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: include
static
int include(STRING* self, char* const str)
{
    size_t  pos     = 0,
            len     = 0;

    char*   p       = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (self->size(self) < (len = strlen(str)) ||
            !len)
        return (status = EOUTOFRANGE);

    p = self->c_str(self);
    while (*p != '\0' &&
            pos <= (self->size(self) - len)) {
        if (memcmp(p, str, len) == 0)
            return 1;
        pos++;
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq *0xa0(%rdi)
movl $0xfffffffc, %r15d      # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x8c89
movq %r14, %rdi
callq *0x18(%r14)
movq %rax, %r13
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r12
decq %rax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %r13, %rax
jae 0x8c89
movq %r14, %rdi
callq *0xc8(%r14)
cmpb $0x0, (%rax)
je 0x8ca5
movq %rax, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r14, %rdi
callq *0x18(%r14)
subq %r12, %rax
cmpq %rax, %rbp
ja 0x8c93
movq %r13, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x22c0
testl %eax, %eax
je 0x8caa
cmpb $0x0, 0x1(%r13,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x8c57
jmp 0x8c93
leaq 0x85e8(%rip), %rax      # 0x11278
movl %r15d, (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x8c93
movl $0x1, %r15d
jmp 0x8c93
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: ts_index
static
int ts_index(STRING* self, char* const str, size_t pos, size_t* idx)
{
    size_t  len     = 0;

    char*   p       = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (str == NULL || idx == NULL)
        return (status = EARGISNULPTR);
    if (!is_in_range(self, pos) ||
            !is_in_range(self, pos + (len = strlen(str))))
        return (status = EOUTOFRANGE);

    p = self->c_str(self) + (*idx = pos);
    while (*p != '\0' &&
            *idx <= (self->size(self) - len)) {
        if (memcmp(p, str, len) == 0)
            return 0;
        (*idx)++;
        p++;
    }
    /* not found */
    *idx = 0;

    return (status = ESTRNOTFOUND);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq *0xa0(%rdi)
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x8d7f
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movl $0xfffffffb, %ebp       # imm = 0xFFFFFFFB
jne 0x8d7f
movq %r15, %rdi
callq *0x18(%r15)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %r12, %rax
jb 0x8d7f
movq %r14, %rdi
callq 0x21b0
movq %rax, %r13
addq %r12, %rax
movq %rax, (%rsp)
movq %r15, %rdi
callq *0x18(%r15)
cmpq (%rsp), %rax
jb 0x8d7f
movq %r15, %rdi
callq *0xc8(%r15)
movq %r12, (%rbx)
cmpb $0x0, (%rax,%r12)
je 0x8d73
movq %rax, %rbp
addq %r12, %rbp
movq %r15, %rdi
callq *0x18(%r15)
subq %r13, %rax
cmpq %rax, %r12
ja 0x8d73
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x22c0
testl %eax, %eax
je 0x8d99
movq (%rbx), %r12
incq %r12
movq %r12, (%rbx)
cmpb $0x0, 0x1(%rbp)
leaq 0x1(%rbp), %rbp
jne 0x8d3f
movq $0x0, (%rbx)
movl $0xfffffffa, %ebp       # imm = 0xFFFFFFFA
leaq 0x84f2(%rip), %rax      # 0x11278
movl %ebp, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x8d88
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbindex
static
int mbindex(STRING* self, char* const str, size_t pos, size_t* idx)
{
    int     ch      = 0;

    size_t  len     = 0;

    char*   p       = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (str == NULL || idx == NULL)
        return (status = EARGISNULPTR);
    if (!mb_is_in_range(self, pos))
        return (status = EOUTOFRANGE);

    len = strlen(str);
    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
            return (status = EINVALIDCHAR);
        }
        if (pos)
            pos--;
        else if (memcmp(p, str, len) == 0)
            return 0;
        p += ch;
        (*idx)++;
    }
    /* not found */
    *idx = 0;

    return (status = ESTRNOTFOUND);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
callq *0xa0(%rdi)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x8f65
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
jne 0x8f65
movq %r13, %rdi
callq *0x20(%r13)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %r15, %rax
jb 0x8f65
movq %r14, %rdi
callq 0x21b0
movq %rax, %r12
movq %r13, %rdi
callq *0xc8(%r13)
movq %rax, %r13
leaq 0x34d1(%rip), %rsi      # 0xc3ce
xorl %edi, %edi
callq 0x2430
cmpb $0x0, (%r13)
je 0x8f52
callq 0x21d0
movq %r13, %rdi
movq %rax, %rsi
callq 0x2310
testl %eax, %eax
js 0x8f60
movl %eax, %ebp
testq %r15, %r15
je 0x8f2b
decq %r15
jmp 0x8f40
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x22c0
xorl %r15d, %r15d
testl %eax, %eax
je 0x8f71
movl %ebp, %eax
incq (%rbx)
cmpb $0x0, (%r13,%rax)
leaq (%r13,%rax), %r13
jne 0x8f0b
movq $0x0, (%rbx)
movl $0xfffffffa, %ecx       # imm = 0xFFFFFFFA
jmp 0x8f65
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq 0x830c(%rip), %rax      # 0x11278
movl %ecx, (%rax)
movl %ecx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbrindex
static
int mbrindex(STRING* self, char* const str, size_t pos, size_t* idx)
{
    int     ch      = 0;

    size_t  off     = 0,
            len     = 0;

    char*   p       = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (str == NULL || idx == NULL)
        return (status = EARGISNULPTR);
    if (!mb_is_in_range(self, pos))
        return (status = EOUTOFRANGE);

    len = strlen(str);
    *idx = self->mblen(self) - 1;
    p = self->c_str(self) + self->size(self) - 1;
    setlocale(LC_CTYPE, T_STRING_LOCALE_VALUE);
    while (off < self->size(self)) {
        while (mblen(p, MB_CUR_MAX) < 0 && p--)
            off++;
        if ((ch = mblen(p, MB_CUR_MAX)) < 0) {
#ifdef  LIBRARY_VERBOSE
            print_error();
/* LIBRARY_VERBOSE */
#endif
            return (status = EINVALIDCHAR);
        }
        if (pos)
            pos--;
        else if (memcmp(p, str, len) == 0)
            return 0;
        off++;
        p--;
        (*idx)--;
    }
    /* not found */
    *idx = 0;

    return (status = ESTRNOTFOUND);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq *0xa0(%rdi)
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
testl %eax, %eax
jne 0x909b
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
jne 0x909b
movq %r15, %rdi
callq *0x20(%r15)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %r12, %rax
jb 0x909b
movq %r14, %rdi
callq 0x21b0
movq %rax, (%rsp)
movq %r15, %rdi
callq *0x20(%r15)
decq %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq *0xc8(%r15)
movq %rax, %rbp
movq %r15, %rdi
callq *0x18(%r15)
movq %rax, %r13
leaq 0x33bc(%rip), %rsi      # 0xc3ce
xorl %edi, %edi
callq 0x2430
movq %r15, %rdi
callq *0x18(%r15)
testq %rax, %rax
je 0x9088
addq %r13, %rbp
xorl %r13d, %r13d
decq %rbp
callq 0x21d0
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2310
incq %r13
testl %eax, %eax
js 0x902b
callq 0x21d0
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2310
testl %eax, %eax
js 0x9096
testq %r12, %r12
je 0x9063
decq %r12
jmp 0x9079
movq %rbp, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
callq 0x22c0
xorl %r12d, %r12d
testl %eax, %eax
je 0x90a7
decq (%rbx)
movq %r15, %rdi
callq *0x18(%r15)
cmpq %rax, %r13
jb 0x902b
movq $0x0, (%rbx)
movl $0xfffffffa, %ecx       # imm = 0xFFFFFFFA
jmp 0x909b
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq 0x81d6(%rip), %rax      # 0x11278
movl %ecx, (%rax)
movl %ecx, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: slice
static
int slice(STRING** self, char* const str)
{
    size_t  pos     = 0,
            len     = 0;

    char*   p       = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);
    if ((*self)->size(*self) < (len = strlen(str)) ||
            !len)
        return (status = EOUTOFRANGE);

    p = (*self)->c_str(*self);
    while (*p != '\0' &&
            pos <= ((*self)->size(*self) - len)) {
        if (memcmp(p, str, len) == 0) {
            p = (*self)->c_str(*self);
            memmove(p + pos, p + pos + len, (*self)->size(*self) - len);
            memset(p + (*self)->size(*self) - len, '\0', len);
            (*self)->length -= len;
            break;
        }
        pos++;
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x90ef
leaq 0x819a(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %r12d      # imm = 0xFFFFFFFC
jmp 0x91be
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r12
movq %r15, %rdi
callq 0x21b0
movq %rax, %r14
decq %rax
cmpq %r12, %rax
jae 0x9157
movq (%rbx), %rdi
callq *0xc8(%rdi)
cmpb $0x0, (%rax)
je 0x916c
movq %rax, %rbp
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rdi
callq *0x18(%rdi)
subq %r14, %rax
cmpq %rax, %r13
ja 0x91be
movq %rbp, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22c0
testl %eax, %eax
je 0x9171
cmpb $0x0, 0x1(%rbp,%r13)
leaq 0x1(%r13), %r13
jne 0x9122
jmp 0x91be
leaq 0x811a(%rip), %rax      # 0x11278
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x91be
xorl %r12d, %r12d
jmp 0x91be
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %r15
addq %rax, %r13
leaq (%r14,%r13), %r12
movq (%rbx), %rdi
callq *0x18(%rdi)
subq %r14, %rax
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2340
movq (%rbx), %rdi
callq *0x18(%rdi)
addq %rax, %r15
subq %r14, %r15
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2050
movq (%rbx), %rax
subq %r14, 0x8(%rax)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: delete_prefix
static
int delete_prefix(STRING** self, char* const str)
{
    size_t  len = 0;

    char*   p   = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);
    if ((*self)->size(*self) < (len = strlen(str)) ||
            !len)
        return 0;

    p = (*self)->c_str(*self);
    if (memcmp(p, str, len) == 0) {
        memmove(p, p + len, (*self)->size(*self) - len);
        memset(p + (*self)->size(*self) - len, '\0', len);
        (*self)->length -= len;
    } else {
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x91ff
leaq 0x8086(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0x927b
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r15
movq %r12, %rdi
callq 0x21b0
movq %rax, %r14
decq %rax
xorl %ebp, %ebp
cmpq %r15, %rax
jae 0x927b
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x22c0
testl %eax, %eax
jne 0x927b
leaq (%r15,%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)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: delete_suffix
static
int delete_suffix(STRING** self, char* const str)
{
    size_t  len = 0;

    char*   p   = NULL;

    if ((*self)->empty(*self))
        return (status = ESTRISEMPTY);
    if ((*self)->size(*self) < (len = strlen(str)) ||
            !len)
        return 0;

    p = (*self)->c_str(*self) + (*self)->size(*self) - len;
    if (memcmp(p, str, len) == 0) {
        memset(p, '\0', len);
        (*self)->length -= len;
    } else {
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0xa0(%rdi)
testl %eax, %eax
je 0x92b8
leaq 0x7fcd(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0x931c
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r12
movq %r14, %rdi
callq 0x21b0
movq %rax, %r15
decq %rax
xorl %ebp, %ebp
cmpq %r12, %rax
jae 0x931c
movq (%rbx), %rdi
callq *0xc8(%rdi)
movq %rax, %r13
movq (%rbx), %rdi
callq *0x18(%rdi)
movq %rax, %r12
addq %r13, %r12
subq %r15, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22c0
testl %eax, %eax
jne 0x931c
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2050
movq (%rbx), %rax
subq %r15, 0x8(%rax)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: to_i
static
int to_i(STRING* self, int base)
{
    if (self->empty(self))
        return (status = ESTRISEMPTY);

    if (base <= 0)
        base = 10;
    errno = 0;

    return (int)strtol(self->c_str(self), NULL, base);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq *0xa0(%rdi)
testl %eax, %eax
je 0x9354
leaq 0x7f31(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x9381
testl %ebp, %ebp
movl $0xa, %r14d
cmovgl %ebp, %r14d
callq 0x2390
movl $0x0, (%rax)
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x22e0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: to_l
static
long to_l(STRING* self, int base)
{
    if (self->empty(self))
        return (status = ESTRISEMPTY);

    if (base <= 0)
        base = 10;
    errno = 0;

    return strtol(self->c_str(self), NULL, base);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq *0xa0(%rdi)
testl %eax, %eax
je 0x93b2
leaq 0x7ed8(%rip), %rax      # 0x11278
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $-0x4, %rax
popq %rbx
popq %r14
popq %rbp
retq
testl %ebp, %ebp
movl $0xa, %r14d
cmovgl %ebp, %r14d
callq 0x2390
movl $0x0, (%rax)
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x22e0