LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: each_char
static
int each_char(STRING* self, void (*fn)(char*))
{
    size_t  y   = 0,
            idx = 0;

    char**  arr = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (fn == NULL)
        return (status = EARGISNULPTR);

    if ((self)->to_char_arr(self, &arr) < 0)
        return status;

    idx = self->mblen(self);
    while (y < idx) {
        fn(arr[y]);
        free(arr[y]);
        y++;
    }
    free(arr);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xe997
leaq 0x88c3(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xea3c
cmpq $0x0, -0x18(%rbp)
jne 0xe9b7
leaq 0x88a3(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xea3c
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0xe9df
leaq 0x8870(%rip), %rax      # 0x17248
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xea3c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xea2c
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe9f1
movq -0x30(%rbp), %rdi
callq 0x2180
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: each_codepoint
static
int each_codepoint(STRING* self, void (*fn)(uint32_t))
{
    int         ch  = 0;

    char*       p   = NULL;

    gunichar*   cp  = NULL;

    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (fn == NULL)
        return (status = EARGISNULPTR);

    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);
        }
        cp = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);
        fn(*cp);
        g_free(cp);
        p += ch;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xeaa6
leaq 0x87b4(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xeb74
cmpq $0x0, -0x18(%rbp)
jne 0xeac6
leaq 0x8794(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xeb74
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
xorl %edi, %edi
leaq 0x3a38(%rip), %rsi      # 0x1251c
callq 0x23d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xeb6d
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x21b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0xeb2c
leaq 0x872b(%rip), %rax      # 0x17248
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xeb74
movq -0x28(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %edi
callq *%rax
movq -0x30(%rbp), %rdi
callq 0x2030
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xeae9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: ts_crypt
static
char* ts_crypt(STRING* self, char* const salt)
{
    if (self->empty(self)) {
        status = ESTRISEMPTY;

        return NULL;
    }
    if (salt == NULL) {
        status = EARGISNULPTR;

        return NULL;
    }

    return crypt(self->c_str(self), salt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0xebbd
leaq 0x869b(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, -0x8(%rbp)
jmp 0xebfc
cmpq $0x0, -0x18(%rbp)
jne 0xebdb
leaq 0x867d(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movq $0x0, -0x8(%rbp)
jmp 0xebfc
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2170
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: ts_crypt2
static
int ts_crypt2(STRING* self, char* const salt, char** dest)
{
    if (self->empty(self))
        return (status = ESTRISEMPTY);
    if (salt == NULL)
        return (status = EARGISNULPTR);

    if ((*dest = crypt(self->c_str(self), salt)) == NULL)
        return errno;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xec50
leaq 0x8607(%rip), %rax      # 0x17248
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xecaa
cmpq $0x0, -0x18(%rbp)
jne 0xec6d
leaq 0x85ea(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xecaa
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2170
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xeca3
callq 0x2350
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xecaa
movl $0x0, -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: clear
static
void clear(STRING** self)
{
    if ((*self)->string != NULL) {
        free((*self)->string);
        (*self)->string = NULL;
    }
    (*self)->length     = 0;
    (*self)->alloc_size = 0;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xecf9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%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: release
static
void release(STRING* self)
{
    if (self != NULL) {
        if (self->string != NULL) {
            free(self->string);
            self->string = NULL;
        }
        free(self);
        self = NULL;
    }
            
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xed68
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xed57
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2180
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbstrlen
static
size_t mbstrlen(char* const str)
{
    int     ch      = 0;

    size_t  c       = 0;

    char*   p       = NULL;

    if (str == NULL) {
        status = EARGISNULPTR; goto ERR;
    } else {
        p = str;
    }
    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)
cmpq $0x0, -0x10(%rbp)
jne 0xeda9
leaq 0x84a7(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0xee24
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %edi, %edi
leaq 0x3762(%rip), %rsi      # 0x1251c
callq 0x23d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xee1a
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 0xedfb
leaq 0x8455(%rip), %rax      # 0x17248
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0xee24
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 0xedbf
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xee2c
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: fputline
int 
fputline(FILE* fp, STRING* s)
{
    if (fp == NULL || s == NULL) {
        status = EARGISNULPTR; goto ERR;
    }

    return fputs(s->c_str(s), fp);

ERR:
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeffe
cmpq $0x0, -0x18(%rbp)
jne 0xf00d
leaq 0x8243(%rip), %rax      # 0x17248
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jmp 0xf02f
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x22a0
movl %eax, -0x4(%rbp)
jmp 0xf03b
leaq 0x8212(%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: release_char_arr
void
release_char_arr(STRING* self, size_t n, char** arr)
{
    size_t  y   = 0;

    if (self != NULL)
        n = self->mblen(self);

    if (arr != NULL) {
        while (y < n) {
            if (*(arr + y) != NULL) {
                free(*(arr + y));
                *(arr + y) = NULL;
            }
            y++;
        }
        free(arr);
        arr = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf085
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf0e7
jmp 0xf08e
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xf0d6
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf0c8
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf08e
movq -0x18(%rbp), %rdi
callq 0x2180
movq $0x0, -0x18(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: reallocate_memory
static
int reallocate_memory(STRING** self, size_t size)
{
    if (((*self)->length + size) < (*self)->alloc_size)
        return 0;

    size_t  old_alloc_size  = (*self)->alloc_size;

    while ((*self)->alloc_size < ((*self)->length + size))
        (*self)->alloc_size += T_STRING_DEFAULT_ALLOC_SIZE;

    if (((*self)->string = (char*)
                realloc((*self)->string,
                    sizeof(char) * (*self)->alloc_size)) == NULL) {
#ifdef  LIBRARY_VERBOSE
        print_error();
/* LIBRARY_VERBOSE */
#endif
        return (status = EMEMORYALLOC);
    } else {
        memset((*self)->string + old_alloc_size,
                '\0', (*self)->alloc_size - old_alloc_size);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jae 0xf137
movl $0x0, -0x4(%rbp)
jmp 0xf1e9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0xf179
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, (%rax)
jmp 0xf145
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 0xf1be
leaq 0x8099(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xf1e9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
subq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x2050
movl $0x0, -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: allocate_memory
static
int allocate_memory(STRING** self, size_t size)
{
    while ((*self)->alloc_size < size)
        (*self)->alloc_size += T_STRING_DEFAULT_ALLOC_SIZE;

    if (((*self)->string = (char*)
                malloc(sizeof(char) * (*self)->alloc_size)) == NULL) {
#ifdef  LIBRARY_VERBOSE
        print_error();
/* LIBRARY_VERBOSE */
#endif
        return (status = EMEMORYALLOC);
    } else {
        memset((*self)->string, '\0', (*self)->alloc_size);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0xf236
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, (%rax)
jmp 0xf210
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x20e0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xf270
leaq 0x7fe7(%rip), %rax      # 0x17248
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xf293
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
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: mbstrtok
static
char* mbstrtok(char* str, char* delim)
{
    static  char*   ptr = NULL;
            char*   bdy = NULL;

    if (!str)
        str = ptr;

    if (!str)
        return NULL;

    if ((bdy = strstr(str, delim)) != NULL) {
        *bdy = '\0';
        ptr = bdy + strlen(delim);
    } else {
        ptr = NULL;
    }

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf30a
movq 0x7f4a(%rip), %rax      # 0x17250
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf31b
movq $0x0, -0x8(%rbp)
jmp 0xf370
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2270
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf35d
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, 0x7ef5(%rip)      # 0x17250
jmp 0xf368
movq $0x0, 0x7ee8(%rip) # 0x17250
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/typestring.c
// Function: count_mb_witdh
static
int count_mb_witdh(STRING* self, size_t* s)
{
    int         ch  = 0;

    char*       p   = self->c_str(self);

    gunichar*   cp  = NULL;

    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 (ch > 1) {
            cp = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);
            if ((*cp >= 0xff65 && *cp <= 0xff9f))
                (*s)++;
            else
                (*s) += 2;
            g_free(cp);
        } else {
            (*s)++;
        }
        p += ch;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %edi, %edi
leaq 0x315f(%rip), %rsi      # 0x1251c
callq 0x23d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xf48d
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x21b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0xf40c
leaq 0x7e4e(%rip), %rax      # 0x17248
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf494
cmpl $0x1, -0x1c(%rbp)
jle 0xf469
movq -0x28(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0xff65, (%rax)         # imm = 0xFF65
jb 0xf450
movq -0x30(%rbp), %rax
cmpl $0xff9f, (%rax)         # imm = 0xFF9F
ja 0xf450
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xf45e
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x2030
jmp 0xf477
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xf3c2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/clangsay.c
// Function: release
static
void release(COW* cow, MSG* msg)
{
    if (cow != NULL)
        cow->release(cow);

    if (msg != NULL)
        msg->release(msg);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfc35
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
cmpq $0x0, -0x10(%rbp)
je 0xfc4a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/cow.c
// Function: init_cow
int init_cow(COW** cow)
{
    int     status  = 0;

    COW*    tmp     = NULL;

    if ((tmp = (COW*)
                malloc(sizeof(COW))) == NULL) {
        status = -1; goto ERR;
    }
    do {
        tmp->fp         = NULL;
        tmp->data       = NULL;
        tmp->lines      = 0;
        tmp->open       = open_cow;
        tmp->read       = read_cow;
        tmp->print      = print_cow;
        tmp->release    = release_cow;
    } while (0);
    *cow = tmp;

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stderr, "%s: malloc(): %s\n",
                    PROGNAME, strerror(errno));
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x38, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xfc88
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcfc
jmp 0xfc8a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x99(%rip), %rcx        # 0xfd50
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x2fa(%rip), %rcx       # 0xffc0
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq 0x41b(%rip), %rcx       # 0x100f0
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
leaq 0x94c(%rip), %rcx       # 0x10630
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xfd42
movl -0x14(%rbp), %eax
subl $-0x1, %eax
jne 0xfd3c
jmp 0xfd06
movq 0x72db(%rip), %rax      # 0x16fe8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2350
movl (%rax), %edi
callq 0x2260
movq -0x28(%rbp), %rdi
movq %rax, %rcx
leaq 0x269e(%rip), %rsi      # 0x123cc
leaq 0x265c(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/cow.c
// Function: read_cow
static
int read_cow(COW** cow)
{
    int     status  = 0;

    if ((*cow)->fp == NULL) {
        status = -1; goto ERR;
    }
    if (((*cow)->lines =
                load_file_to_array(&(*cow)->data, TH_LINES, TH_LENGTH, (*cow)->fp)) < 0) {
        status = -2; goto ERR;
    }
    fclose((*cow)->fp);

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stdout, "%s: read_cowfile(): fp is NULL\n",
                    PROGNAME);
            break;
        case    -2:
            fprintf(stderr, "%s: read_cowfile(): load_file_to_array(): %s\n",
                    PROGNAME, strerror(errno));
        default:
            if ((*cow)->fp != NULL) {
                fclose((*cow)->fp);
                (*cow)->fp = NULL;
            }
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0xffe9
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x10040
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movl $0x100, %esi            # imm = 0x100
movl $0x200, %edx            # imm = 0x200
callq 0x4a70
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jge 0x10025
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
jmp 0x10040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2390
movl $0x0, -0x4(%rbp)
jmp 0x100e0
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $-0x2, %eax
je 0x10078
jmp 0x1004d
movl -0x18(%rbp), %eax
subl $-0x1, %eax
jne 0x100ae
jmp 0x10057
movq 0x6f9a(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
leaq 0x2413(%rip), %rsi      # 0x1247b
leaq 0x2322(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
jmp 0x100da
movq 0x6f69(%rip), %rax      # 0x16fe8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2350
movl (%rax), %edi
callq 0x2260
movq -0x20(%rbp), %rdi
movq %rax, %rcx
leaq 0x23fb(%rip), %rsi      # 0x1249b
leaq 0x22ea(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x100d8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2390
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
jmp 0x100da
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/cow.c
// Function: release_cow
static
void release_cow(COW* cow)
{
    int     i   = 0,
            j   = 0;

    if (cow != NULL) {
        if (cow->data != NULL) {
            i = 0;
            j = cow->lines - 1;
            while (i <= j) {
                if (*(cow->data + i) != NULL) {
                    free(*(cow->data + i));
                    *(cow->data + i) = NULL;
                }
                if (*(cow->data + j) != NULL) {
                    free(*(cow->data + j));
                    *(cow->data + j) = NULL;
                }
                i++;
                j--;
            }
            free(cow->data);
            cow->data = NULL;
        }
        free(cow);
        cow = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1073d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1072c
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x10713
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x106c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x106fc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10678
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2180
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/cow.c
// Function: check_file_exists
static
int check_file_exists(char* path, char* file)
{
    int     ret     = 0;

    char*   tmp     = NULL;

    DIR*    dp      = NULL;

    struct  stat    st;

    struct  dirent* list;

    /* open directory */
    if ((dp = opendir(path)) == NULL)
        return 0;

    /* concat filename + .cow */
    if ((tmp = strlion(2, file, ".cow")) == NULL) {
        closedir(dp);

        return 0;
    }

    /* search cowfile from directory */
    for (list = readdir(dp); list != NULL; list = readdir(dp)) {
        if (strcmp(list->d_name, file) == 0) {
            ret = 2;
            break;
        } else if (strcmp(list->d_name, tmp) == 0) {
            ret = 3;
            break;
        }
    }
    closedir(dp);
    free(tmp);

    /* outside of env */
    if (ret == 0) {
        if (stat(file, &st) == 0)
            ret = 1;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x10959
movl $0x0, -0x4(%rbp)
jmp 0x10a3f
movq -0x18(%rbp), %rsi
movl $0x2, %edi
leaq 0x1a48(%rip), %rdx      # 0x123b1
movb $0x0, %al
callq 0x8270
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1098f
movq -0x30(%rbp), %rdi
callq 0x23a0
movl $0x0, -0x4(%rbp)
jmp 0x10a3f
movq -0x30(%rbp), %rdi
callq 0x21d0
movq %rax, -0xc8(%rbp)
cmpq $0x0, -0xc8(%rbp)
je 0x10a03
movq -0xc8(%rbp), %rdi
addq $0x13, %rdi
movq -0x18(%rbp), %rsi
callq 0x2360
cmpl $0x0, %eax
jne 0x109cb
movl $0x2, -0x1c(%rbp)
jmp 0x10a03
movq -0xc8(%rbp), %rdi
addq $0x13, %rdi
movq -0x28(%rbp), %rsi
callq 0x2360
cmpl $0x0, %eax
jne 0x109ed
movl $0x3, -0x1c(%rbp)
jmp 0x10a03
jmp 0x109ef
jmp 0x109f1
movq -0x30(%rbp), %rdi
callq 0x21d0
movq %rax, -0xc8(%rbp)
jmp 0x1099f
movq -0x30(%rbp), %rdi
callq 0x23a0
movq -0x28(%rbp), %rdi
callq 0x2180
cmpl $0x0, -0x1c(%rbp)
jne 0x10a39
movq -0x18(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2400
cmpl $0x0, %eax
jne 0x10a37
movl $0x1, -0x1c(%rbp)
jmp 0x10a39
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/cow.c
// Function: concat_file_path
static
int concat_file_path(int mode, char** dest, char* path, char* file)
{
    int     status  = 0;

    switch (mode) {
        case    1:
            if ((*dest = (char*)
                        smalloc(sizeof(char) * strlen(file), NULL)) == NULL) {
                status = -1; goto ERR;
            }
            memcpy(*dest, file, strlen(file) + 1);
            break;
        case    2:
            *dest = strlion(3, path, "/", file);
            break;
        case    3:
            *dest = strlion(4, path, "/", file, ".cow");
            break;
    }
    if (*dest == NULL) {
        status =  -2; goto ERR;
    }

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            fprintf(stderr, "%s: concat_file_path() failure\n",
                    PROGNAME);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x10a96
jmp 0x10a7b
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x10afc
jmp 0x10a85
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x10b23
jmp 0x10b4f
movq -0x20(%rbp), %rdi
callq 0x2190
movq %rax, %rdi
shlq $0x0, %rdi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x6160
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x10aca
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b6b
movq -0x10(%rbp), %rax
movq (%rax), %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
addq $0x1, %rdx
callq 0x2410
jmp 0x10b4f
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x3, %edi
leaq 0x1900(%rip), %rdx      # 0x12410
movb $0x0, %al
callq 0x8270
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x10b4f
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x4, %edi
leaq 0x18d9(%rip), %rdx      # 0x12410
leaq 0x1873(%rip), %r8       # 0x123b1
movb $0x0, %al
callq 0x8270
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10b62
movl $0xfffffffe, -0x24(%rbp) # imm = 0xFFFFFFFE
jmp 0x10b6b
movl $0x0, -0x4(%rbp)
jmp 0x10ba9
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $-0x2, %eax
je 0x10b84
jmp 0x10b78
movl -0x3c(%rbp), %eax
subl $-0x1, %eax
jne 0x10ba3
jmp 0x10b82
jmp 0x10ba3
movq 0x645d(%rip), %rax      # 0x16fe8
movq (%rax), %rdi
leaq 0x18c6(%rip), %rsi      # 0x1245b
leaq 0x17f5(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
movl -0x24(%rbp), %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/cow.c
// Function: replace_escaped_backslash
static
void replace_escaped_backslash(char* str)
{
    int     c       = 0;

    char*   p       = str;

    while (*p != '\0') {
        if ((*p == '\\' && *(p + 1) != '\0') && *(p + 1) == '\\') {
            c++;
            p++;
        }
        p++;
    }
    while (c) {
        strrep(str, "\\\\", "\\");
        c--;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x10c30
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x10c22
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x10c22
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x10c22
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10bdb
jmp 0x10c32
cmpl $0x0, -0xc(%rbp)
je 0x10c5a
movq -0x8(%rbp), %rdi
leaq 0x18c3(%rip), %rsi      # 0x12506
leaq 0x1d90(%rip), %rdx      # 0x129da
callq 0x7f60
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10c32
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/list.c
// Function: list_cowfiles
int list_cowfiles(void)
{
    int     i       = 0,
            j       = 0,
            entry   = 0;

    char*   env     = NULL;

    env_t*  envt    = NULL;

    struct  dirent**  list;

    /* catenate file path */
    if ((env = getenv("COWPATH")) == NULL)
        env = COWPATH;

    if (split_env(env, &envt) < 0) {
        fprintf(stderr, "%s: list_cowfiles(): split_env() failure\n",
                PROGNAME);

        exit(8);
    }

    /* get file entry and sort */
    do {
        if ((entry = scandir(*(envt->envs + i),
                        &list, selects_cowfiles, alphasort)) != -1) {
            if (i > 0)
                puts("");
            fprintf(stdout, "%s:\n",
                    *(envt->envs + i));
            j = 0;
            while (j < entry) {
                fprintf(stdout, "%s\n",
                        list[j]->d_name);
                free(*(list + j));
                j++;
            }
            free(list);
        }
        i++;
    } while (i < envt->envc);
    release_env_t(envt);

    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x1686(%rip), %rdi      # 0x123ea
callq 0x2340
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x10d7e
leaq 0x1678(%rip), %rax      # 0x123f2
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x46c0
cmpl $0x0, %eax
jge 0x10db9
movq 0x6251(%rip), %rax      # 0x16fe8
movq (%rax), %rdi
leaq 0x1ba3(%rip), %rsi      # 0x12944
leaq 0x15e9(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
movl $0x8, %edi
callq 0x20c0
jmp 0x10dbb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x28(%rbp), %rsi
leaq 0xda(%rip), %rdx        # 0x10eb0
movq 0x61fb(%rip), %rcx      # 0x16fd8
callq 0x2140
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x10e84
cmpl $0x0, -0x4(%rbp)
jle 0x10e00
leaq 0x1721(%rip), %rdi      # 0x1251c
callq 0x2080
movq 0x61f1(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1b4d(%rip), %rsi      # 0x1296e
movb $0x0, %al
callq 0x23f0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x10e7b
movq 0x61ba(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq 0x1bcf(%rip), %rsi      # 0x12a27
movb $0x0, %al
callq 0x23f0
movq -0x28(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x10e2f
movq -0x28(%rbp), %rdi
callq 0x2180
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x10dbb
movq -0x20(%rbp), %rdi
callq 0x48f0
xorl %edi, %edi
callq 0x20c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/list.c
// Function: selects_cowfiles
static
int selects_cowfiles(const struct dirent* dir)
{
    char*   tcow  = ".cow\0";

    if (strlen(dir->d_name) < 5)
        return 0;

    if (memcmp(dir->d_name + (strlen(dir->d_name) - 4), tcow, 5) == 0)
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1ab0(%rip), %rax      # 0x12973
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x13, %rdi
callq 0x2190
cmpq $0x5, %rax
jae 0x10ee3
movl $0x0, -0x4(%rbp)
jmp 0x10f2a
movq -0x10(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x13, %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
subq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0x2380
cmpl $0x0, %eax
jne 0x10f23
movl $0x1, -0x4(%rbp)
jmp 0x10f2a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/msg.c
// Function: init_msg
int init_msg(MSG** msg)
{
    int     status  = 0;

    MSG*    tmp     = NULL;

    if ((tmp = (MSG*)
                malloc(sizeof(MSG))) == NULL) {
        status = -1; goto ERR;
    }
    do {
        tmp->data       = NULL;
        tmp->lines      = 0;
        tmp->read       = read_msg;
        tmp->print      = print_msg;
        tmp->recursive  = recursive_msg;
        tmp->release    = release_msg;
    } while (0);
    *msg = tmp;

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stderr, "%s: malloc(): %s\n",
                    PROGNAME, strerror(errno));
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x30, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x10f78
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x10fe0
jmp 0x10f7a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
leaq 0x95(%rip), %rcx        # 0x11030
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x2a6(%rip), %rcx       # 0x11250
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq 0x597(%rip), %rcx       # 0x11550
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x738(%rip), %rcx       # 0x11700
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x11026
movl -0x14(%rbp), %eax
subl $-0x1, %eax
jne 0x11020
jmp 0x10fea
movq 0x5ff7(%rip), %rax      # 0x16fe8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2350
movl (%rax), %edi
callq 0x2260
movq -0x28(%rbp), %rdi
movq %rax, %rcx
leaq 0x13ba(%rip), %rsi      # 0x123cc
leaq 0x1378(%rip), %rdx      # 0x12391
movb $0x0, %al
callq 0x23f0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/msg.c
// Function: release_msg
static
void release_msg(MSG* msg)
{
    int     i   = 0,
            j   = 0;

    if (msg != NULL) {
        if (msg->data != NULL) {
            i = 0;
            j = msg->lines - 1;
            while (i <= j) {
                if (*(msg->data + i) != NULL) {
                    free(*(msg->data + i));
                    *(msg->data + i) = NULL;
                }
                if (*(msg->data + j) != NULL) {
                    free(*(msg->data + j));
                    *(msg->data + j) = NULL;
                }
                i++;
                j--;
            }
            free(msg->data);
            msg->data = NULL;
        }
        free(msg);
        msg = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11804
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x117f3
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x117dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1178c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x117c5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11747
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2180
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/msg.c
// Function: strunsecs
static
void strunsecs(MSG** msg)
{
    int i   = 0,
        j   = (*msg)->lines - 1;

    while (i <= j && i < (*msg)->lines) {
        strunesc(*((*msg)->data + i));
        strunesc(*((*msg)->data + j));
        i++;
        j--;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x11(%rbp)
jg 0x11853
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1185c
jmp 0x1189e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8610
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8610
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11833
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/msg.c
// Function: read_recursive_msg
static
int read_recursive_msg(MSG** msg, int fd)
{
    int     status  = 0;

    FILE*   fp      = NULL;

    if ((*msg)->data != NULL) {
        free2d((*msg)->data, (*msg)->lines);
        (*msg)->lines = 0;
        (*msg)->data = NULL;
    }
    if ((fp = fdopen(fd, "r")) == NULL) {
        status = -1; goto ERR;
    }
    if (((*msg)->lines = 
                load_file_to_array(&(*msg)->data, TH_LINES, TH_LENGTH, fp)) < 0) {
        status = -2; goto ERR;
    }
    fclose(fp);

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stderr, "%s: read_recursive_msg(): fdopen() %s\n",
                    PROGNAME, strerror(errno));
            break;
        case    -2:
            fprintf(stderr, "%s: read_recursive_msg(): load_file_to_array(): %s\n",
                    PROGNAME, strerror(errno));
            break;
    }
    if (fp != NULL)
        fclose(fp);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x11910
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x6400
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %edi
leaq 0x1090(%rip), %rsi      # 0x129aa
callq 0x2200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x11932
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x11979
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
movl $0x200, %edx            # imm = 0x200
callq 0x4a70
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, 0x8(%rcx)
cmpl $0x0, %eax
jge 0x11964
movl $0xfffffffe, -0x18(%rbp) # imm = 0xFFFFFFFE
jmp 0x11979
movq -0x20(%rbp), %rdi
callq 0x2390
movl $0x0, -0x4(%rbp)
jmp 0x11a14
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $-0x2, %eax
je 0x119c8
jmp 0x11986
movl -0x24(%rbp), %eax
subl $-0x1, %eax
jne 0x119fe
jmp 0x11990
movq 0x5651(%rip), %rax      # 0x16fe8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2350
movl (%rax), %edi
callq 0x2260
movq -0x30(%rbp), %rdi
movq %rax, %rcx
leaq 0x104c(%rip), %rsi      # 0x12a04
leaq 0x9d2(%rip), %rdx       # 0x12391
movb $0x0, %al
callq 0x23f0
jmp 0x119fe
movq 0x5619(%rip), %rax      # 0x16fe8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x2350
movl (%rax), %edi
callq 0x2260
movq -0x38(%rbp), %rdi
movq %rax, %rcx
leaq 0x103b(%rip), %rsi      # 0x12a2b
leaq 0x99a(%rip), %rdx       # 0x12391
movb $0x0, %al
callq 0x23f0
cmpq $0x0, -0x20(%rbp)
je 0x11a0e
movq -0x20(%rbp), %rdi
callq 0x2390
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/synthReadGen.c
// Function: getComplimentRes
char getComplimentRes(const char res){
  if(res == 'A'){return 'T';}
  if(res == 'T'){return 'A';}
  if(res == 'G'){return 'C';}
  return 'G';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jne 0x1299
movb $0x54, -0x1(%rbp)
jmp 0x12bb
movsbl -0x2(%rbp), %eax
cmpl $0x54, %eax
jne 0x12a8
movb $0x41, -0x1(%rbp)
jmp 0x12bb
movsbl -0x2(%rbp), %eax
cmpl $0x47, %eax
jne 0x12b7
movb $0x43, -0x1(%rbp)
jmp 0x12bb
movb $0x47, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/synthReadGen.c
// Function: intFact
int intFact(int temp){
  if(temp > 0){
    return intFact(temp - 1);
  }else{
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x12e1
movl -0x8(%rbp), %edi
subl $0x1, %edi
callq 0x12c0
movl %eax, -0x4(%rbp)
jmp 0x12e8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)