LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8str
void *utf8str(const void *haystack, const void *needle)
{
    const char *h = (const char *)haystack;
    utf8_int32_t throwaway_codepoint;

    // if needle has no utf8 codepoints before the null terminating
    // byte then return haystack
    if ('\0' == *((const char *)needle)) {
        return (void *)haystack;
    }

    while ('\0' != *h) {
        const char *maybeMatch = h;
        const char *n = (const char *)needle;

        while (*h == *n && (*h != '\0' && *n != '\0')) {
            n++;
            h++;
        }

        if ('\0' == *n) {
            // we found the whole utf8 string for needle in haystack at
            // maybeMatch, so return it
            return (void *)maybeMatch;
        } else {
            // h could be in the middle of an unmatching utf8 codepoint,
            // so we need to march it on to the next character beginning
            // starting from the current character
            h = (const char *)utf8codepoint(maybeMatch, &throwaway_codepoint);
        }
    }

    // no match
    return utf8_null;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x10df2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10eab
jmp 0x10df4
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x10ea3
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movq -0x38(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jne 0x10e53
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x10e4d
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x10e5c
jmp 0x10e76
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10e15
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x10e8d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10eab
movq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x10440
movq %rax, -0x20(%rbp)
jmp 0x10df4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8cmp
int utf8cmp(const void *src1, const void *src2)
{
    const unsigned char *s1 = (const unsigned char *)src1;
    const unsigned char *s2 = (const unsigned char *)src2;

    while (('\0' != *s1) || ('\0' != *s2)) {
        if (*s1 < *s2) {
            return -1;
        } else if (*s1 > *s2) {
            return 1;
        }

        s1++;
        s2++;
    }

    // both utf8 strings matched
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %edx
movb $0x1, %al
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jne 0x10eff
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x10f08
jmp 0x10f5a
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x10f23
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10f61
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x10f3e
movl $0x1, -0x4(%rbp)
jmp 0x10f61
jmp 0x10f40
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10edc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8cpy
void *utf8cpy(void *utf8_restrict dst, const void *utf8_restrict src)
{
    char *d = (char *)dst;
    const char *s = (const char *)src;

    // overwriting anything previously in dst, write byte-by-byte
    // from src
    while ('\0' != *s) {
        *d++ = *s++;
    }

    // append null terminating byte
    *d = '\0';

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x10fbd
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x10f8c
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8cspn
size_t utf8cspn(const void *src, const void *reject)
{
    const char *s = (const char *)src;
    size_t chars = 0;

    while ('\0' != *s) {
        const char *r = (const char *)reject;
        size_t offset = 0;

        while ('\0' != *r) {
            // checking that if *r is the start of a utf8 codepoint
            // (it is not 0b10xxxxxx) and we have successfully matched
            // a previous character (0 < offset) - we found a match
            if ((0x80 != (0xc0 & *r)) && (0 < offset)) {
                return chars;
            } else {
                if (*r == s[offset]) {
                    // part of a utf8 codepoint matched, so move our checking
                    // onwards to the next byte
                    offset++;
                    r++;
                } else {
                    // r could be in the middle of an unmatching utf8 code point,
                    // so we need to march it on to the next character beginning,

                    do {
                        r++;
                    } while (0x80 == (0xc0 & *r));

                    // reset offset too as we found a mismatch
                    offset = 0;
                }
            }
        }

        // the current utf8 codepoint in src did not match reject, but src
        // could have been partway through a utf8 codepoint, so we need to
        // march it onto the next utf8 codepoint starting byte
        do {
            s++;
        } while ((0x80 == (0xc0 & *s)));
        chars++;
    }

    return chars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x110e2
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x110ad
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x11049
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jae 0x11049
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x110ea
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x1107a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x110a6
jmp 0x1107c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x1107c
movq $0x0, -0x38(%rbp)
jmp 0x110a8
jmp 0x1100d
jmp 0x110af
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x110af
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10fec
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8dup
void *utf8dup(const void *src)
{
    const char *s = (const char *)src;
    char *n = utf8_null;

    // figure out how many bytes (including the terminator) we need to copy first
    size_t bytes = utf8size(src);

    n = (char *)malloc(bytes);

    if (utf8_null == n) {
        // out of memory so we bail
        return utf8_null;
    } else {
        bytes = 0;

        // copy src byte-by-byte into our new utf8 string
        while ('\0' != s[bytes]) {
            n[bytes] = s[bytes];
            bytes++;
        }

        // append null terminating byte
        n[bytes] = '\0';
        return n;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x111a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7298
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x11138
movq $0x0, -0x8(%rbp)
jmp 0x1118a
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x11176
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11140
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8size
size_t utf8size(const void *str)
{
    const char *s = (const char *)str;
    size_t size = 0;
    while ('\0' != s[size]) {
        size++;
    }

    // we are including the null terminating byte in the size calculation
    size++;
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x111d8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x111b8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8len
size_t utf8len(const void *str)
{
    const unsigned char *s = (const unsigned char *)str;
    size_t length = 0;

    while ('\0' != *s) {
        if (0xf0 == (0xf8 & *s)) {
            // 4-byte utf8 code point (began with 0b11110xxx)
            s += 4;
        } else if (0xe0 == (0xf0 & *s)) {
            // 3-byte utf8 code point (began with 0b1110xxxx)
            s += 3;
        } else if (0xc0 == (0xe0 & *s)) {
            // 2-byte utf8 code point (began with 0b110xxxxx)
            s += 2;
        } else { // if (0x00 == (0x80 & *s)) {
            // 1-byte ascii (began with 0b0xxxxxxx)
            s += 1;
        }

        // no matter the bytes we marched s forward by, it was
        // only 1 utf8 codepoint
        length++;
    }

    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x112a6
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf8, %ecx
movl $0xf0, %eax
cmpl %ecx, %eax
jne 0x1123d
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x11295
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf0, %ecx
movl $0xe0, %eax
cmpl %ecx, %eax
jne 0x11261
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x11293
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
andl $0xe0, %ecx
movl $0xc0, %eax
cmpl %ecx, %eax
jne 0x11285
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x11291
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11293
jmp 0x11295
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11208
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8width
size_t utf8width(const void *str)
{
    size_t length = 0;
    utf8_int32_t c = 0;

    str = utf8codepoint(str, &c);
    while (c != 0) {
        length += utf8cwidth(c);
        str = utf8codepoint(str, &c);
    }
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x10440
movq %rax, -0x8(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x116d7
movl -0x14(%rbp), %edi
callq 0x112b0
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x10440
movq %rax, -0x8(%rbp)
jmp 0x116ac
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8codepointsize
size_t utf8codepointsize(utf8_int32_t chr)
{
    if (0 == ((utf8_int32_t)0xffffff80 & chr)) {
        return 1;
    } else if (0 == ((utf8_int32_t)0xfffff800 & chr)) {
        return 2;
    } else if (0 == ((utf8_int32_t)0xffff0000 & chr)) {
        return 3;
    } else { // if (0 == ((int)0xffe00000 & chr)) {
        return 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
andl $0xffffff80, %ecx       # imm = 0xFFFFFF80
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x119b0
movq $0x1, -0x8(%rbp)
jmp 0x119ea
movl -0xc(%rbp), %ecx
andl $0xfffff800, %ecx       # imm = 0xFFFFF800
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x119c9
movq $0x2, -0x8(%rbp)
jmp 0x119ea
movl -0xc(%rbp), %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x119e2
movq $0x3, -0x8(%rbp)
jmp 0x119ea
movq $0x4, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8ncat
void *utf8ncat(void *utf8_restrict dst, const void *utf8_restrict src,
               size_t n)
{
    char *d = (char *)dst;
    const char *s = (const char *)src;

    // find the null terminating byte in dst
    while ('\0' != *d) {
        d++;
    }

    // overwriting the null terminating byte in dst, append src byte-by-byte
    // stopping if we run out of space
    do {
        *d++ = *s++;
    } while (('\0' != *s) && (0 != --n));

    // write out a new null terminating byte into dst
    *d = '\0';

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x11a2b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11a10
jmp 0x11a2d
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
je 0x11a78
movq -0x18(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x11a2d
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8ncmp
int utf8ncmp(const void *src1, const void *src2, size_t n)
{
    const unsigned char *s1 = (const unsigned char *)src1;
    const unsigned char *s2 = (const unsigned char *)src2;

    while ((0 != n--) && (('\0' != *s1) || ('\0' != *s2))) {
        if (*s1 < *s2) {
            return -1;
        } else if (*s1 > *s2) {
            return 1;
        }

        s1++;
        s2++;
    }

    // both utf8 strings matched
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq %rdx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
je 0x11af4
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
movb $0x1, %al
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x32(%rbp)
jne 0x11aee
movq -0x30(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11afd
jmp 0x11b52
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x11b18
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b59
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x11b33
movl $0x1, -0x4(%rbp)
jmp 0x11b59
jmp 0x11b35
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11ab0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8ncpy
void *utf8ncpy(void *utf8_restrict dst, const void *utf8_restrict src,
               size_t n)
{
    char *d = (char *)dst;
    const char *s = (const char *)src;
    size_t index;

    // overwriting anything previously in dst, write byte-by-byte
    // from src
    for (index = 0; index < n; index++) {
        d[index] = s[index];
        if ('\0' == s[index]) {
            break;
        }
    }

    // append null terminating byte
    for (; index < n; index++) {
        d[index] = 0;
    }

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x11bcc
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x11bbc
jmp 0x11bcc
jmp 0x11bbe
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11b88
jmp 0x11bce
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x11bf2
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11bce
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8ndup
void *utf8ndup(const void *src, size_t n)
{
    const char *s = (const char *)src;
    char *c = utf8_null;
    size_t bytes = 0;

    // Find the end of the string or stop when n is reached
    while ('\0' != s[bytes] && bytes < n) {
        bytes++;
    }

    // In case bytes is actually less than n, we need to set it
    // to be used later in the copy byte by byte.
    n = bytes;

    c = (char *)malloc(bytes + 1);
    if (utf8_null == c) {
        // out of memory so we bail
        return utf8_null;
    }

    bytes = 0;

    // copy src byte-by-byte into our new utf8 string
    while ('\0' != s[bytes] && bytes < n) {
        c[bytes] = s[bytes];
        bytes++;
    }

    // append null terminating byte
    c[bytes] = '\0';
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
je 0x11c4d
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11c56
jmp 0x11c64
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11c28
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x7298
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x11c8f
movq $0x0, -0x8(%rbp)
jmp 0x11cfd
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x32(%rbp)
je 0x11cbc
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x11cc5
jmp 0x11ce9
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11c97
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8pbrk
void *utf8pbrk(const void *str, const void *accept)
{
    const char *s = (const char *)str;

    while ('\0' != *s) {
        const char *a = (const char *)accept;
        size_t offset = 0;

        while ('\0' != *a) {
            // checking that if *a is the start of a utf8 codepoint
            // (it is not 0b10xxxxxx) and we have successfully matched
            // a previous character (0 < offset) - we found a match
            if ((0x80 != (0xc0 & *a)) && (0 < offset)) {
                return (void *)s;
            } else {
                if (*a == s[offset]) {
                    // part of a utf8 codepoint matched, so move our checking
                    // onwards to the next byte
                    offset++;
                    a++;
                } else {
                    // r could be in the middle of an unmatching utf8 code point,
                    // so we need to march it on to the next character beginning,

                    do {
                        a++;
                    } while (0x80 == (0xc0 & *a));

                    // reset offset too as we found a mismatch
                    offset = 0;
                }
            }
        }

        // we found a match on the last utf8 codepoint
        if (0 < offset) {
            return (void *)s;
        }

        // the current utf8 codepoint in src did not match accept, but src
        // could have been partway through a utf8 codepoint, so we need to
        // march it onto the next utf8 codepoint starting byte
        do {
            s++;
        } while ((0x80 == (0xc0 & *s)));
    }

    return utf8_null;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x12030
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x11ff5
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x11f91
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jae 0x11f91
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12038
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x11fc2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11fee
jmp 0x11fc4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x11fc4
movq $0x0, -0x30(%rbp)
jmp 0x11ff0
jmp 0x11f55
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jae 0x12007
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12038
jmp 0x12009
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x12009
jmp 0x11f34
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8spn
size_t utf8spn(const void *src, const void *accept)
{
    const char *s = (const char *)src;
    size_t chars = 0;

    while ('\0' != *s) {
        const char *a = (const char *)accept;
        size_t offset = 0;

        while ('\0' != *a) {
            // checking that if *r is the start of a utf8 codepoint
            // (it is not 0b10xxxxxx) and we have successfully matched
            // a previous character (0 < offset) - we found a match
            if ((0x80 != (0xc0 & *a)) && (0 < offset)) {
                // found a match, so increment the number of utf8 codepoints
                // that have matched and stop checking whether any other utf8
                // codepoints in a match
                chars++;
                s += offset;
                break;
            } else {
                if (*a == s[offset]) {
                    offset++;
                    a++;
                } else {
                    // a could be in the middle of an unmatching utf8 codepoint,
                    // so we need to march it on to the next character beginning,
                    do {
                        a++;
                    } while (0x80 == (0xc0 & *a));

                    // reset offset too as we found a mismatch
                    offset = 0;
                }
            }
        }

        // if a got to its terminating null byte, then we didn't find a match.
        // Return the current number of matched utf8 codepoints
        if ('\0' == *a) {
            return chars;
        }
    }

    return chars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x12146
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1212a
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x120c6
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jae 0x120c6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1212a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x120f7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12123
jmp 0x120f9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
andl $0xc0, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
je 0x120f9
movq $0x0, -0x38(%rbp)
jmp 0x12125
jmp 0x1207d
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x12141
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1214e
jmp 0x1205c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8casestr
void *utf8casestr(const void *haystack, const void *needle)
{
    const void *h = haystack;

    // if needle has no utf8 codepoints before the null terminating
    // byte then return haystack
    if ('\0' == *((const char *)needle)) {
        return (void *)haystack;
    }

    for (;;) {
        const void *maybeMatch = h;
        const void *n = needle;
        utf8_int32_t h_cp, n_cp;

        // Get the next code point and track it
        const void *nextH = h = utf8codepoint(h, &h_cp);
        n = utf8codepoint(n, &n_cp);

        while ((0 != h_cp) && (0 != n_cp)) {
            h_cp = utf8lwrcodepoint(h_cp);
            n_cp = utf8lwrcodepoint(n_cp);

            // if we find a mismatch, bail out!
            if (h_cp != n_cp) {
                break;
            }

            h = utf8codepoint(h, &h_cp);
            n = utf8codepoint(n, &n_cp);
        }

        if (0 == n_cp) {
            // we found the whole utf8 string for needle in haystack at
            // maybeMatch, so return it
            return (void *)maybeMatch;
        }

        if (0 == h_cp) {
            // no match
            return utf8_null;
        }

        // Roll back to the next code point in the haystack to test
        h = nextH;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x12192
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1225d
jmp 0x12194
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x10440
movq %rax, -0x20(%rbp)
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10440
movq %rax, -0x30(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x34(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x121e1
xorl %eax, %eax
cmpl -0x38(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x121ea
jmp 0x1222e
movl -0x34(%rbp), %edi
callq 0x10580
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %edi
callq 0x10580
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x1220a
jmp 0x1222e
movq -0x20(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x10440
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10440
movq %rax, -0x30(%rbp)
jmp 0x121ca
xorl %eax, %eax
cmpl -0x38(%rbp), %eax
jne 0x1223f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1225d
xorl %eax, %eax
cmpl -0x34(%rbp), %eax
jne 0x12250
movq $0x0, -0x8(%rbp)
jmp 0x1225d
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x12194
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8lwr
void utf8lwr(void *utf8_restrict str)
{
    void *p, *pn;
    utf8_int32_t cp;

    p = (char *)str;
    pn = utf8codepoint(p, &cp);

    while (cp != 0) {
        const utf8_int32_t lwr_cp = utf8lwrcodepoint(cp);
        const size_t size = utf8codepointsize(lwr_cp);

        if (lwr_cp != cp) {
            utf8catcodepoint(p, lwr_cp, size);
        }

        p = pn;
        pn = utf8codepoint(p, &cp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x10440
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x12dd5
movl -0x1c(%rbp), %edi
callq 0x10580
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x11990
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x12dba
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x124e0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x10440
movq %rax, -0x18(%rbp)
jmp 0x12d85
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_create_table
ft_table_t *ft_create_table(void)
{
    ft_table_t *result = (ft_table_t *)F_CALLOC(1, sizeof(ft_table_t));
    if (result == NULL)
        return NULL;

    result->rows = create_vector(sizeof(f_row_t *), DEFAULT_VECTOR_CAPACITY);
    if (result->rows == NULL) {
        F_FREE(result);
        return NULL;
    }
    result->separators = create_vector(sizeof(f_separator_t *), DEFAULT_VECTOR_CAPACITY);
    if (result->separators == NULL) {
        destroy_vector(result->rows);
        F_FREE(result);
        return NULL;
    }

    result->properties = create_table_properties();
    if (result->properties == NULL) {
        destroy_vector(result->separators);
        destroy_vector(result->rows);
        F_FREE(result);
        return NULL;
    }
    result->conv_buffer = NULL;
    result->cur_row = 0;
    result->cur_col = 0;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x30, %esi
callq *0x173a8(%rip)          # 0x2a220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12e90
movq $0x0, -0x8(%rbp)
jmp 0x12f8c
movl $0x8, %edi
movl $0xa, %esi
callq 0x12fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12ecd
movq 0x1736e(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x12f8c
movl $0x8, %edi
movl $0xa, %esi
callq 0x12fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x12f15
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13080
movq 0x17323(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x12f8c
callq 0x130e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x12f60
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x13080
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13080
movq 0x172d8(%rip), %rax     # 0x2a228
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x12f8c
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_vector
FT_INTERNAL
f_vector_t *create_vector(size_t item_size, size_t capacity)
{
    f_vector_t *vector = (f_vector_t *)F_MALLOC(sizeof(f_vector_t));
    if (vector == NULL) {
        return NULL;
    }

    size_t init_size = MAX(item_size * capacity, 1);
    vector->m_data = F_MALLOC(init_size);
    if (vector->m_data == NULL) {
        F_FREE(vector);
        return NULL;
    }

    vector->m_size      = 0;
    vector->m_capacity  = capacity;
    vector->m_item_size = item_size;

    return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
callq *0x173fd(%rip)          # 0x2a3b8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12fd3
movq $0x0, -0x8(%rbp)
jmp 0x13069
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
cmpq $0x1, %rax
jbe 0x12ff1
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x12ffc
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0x12ffc
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x173ad(%rip), %rax     # 0x2a3b8
movq -0x28(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1303e
movq 0x171fa(%rip), %rax     # 0x2a228
movq -0x20(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x13069
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: create_table_properties
FT_INTERNAL
f_table_properties_t *create_table_properties(void)
{
    f_table_properties_t *properties = (f_table_properties_t *)F_CALLOC(sizeof(f_table_properties_t), 1);
    if (properties == NULL) {
        return NULL;
    }
    memcpy(properties, &g_table_properties, sizeof(f_table_properties_t));
    properties->cell_properties = create_cell_prop_container();
    if (properties->cell_properties == NULL) {
        destroy_table_properties(properties);
        return NULL;
    }
    memcpy(&properties->entire_table_properties, &g_entire_table_properties, sizeof(fort_entire_table_properties_t));
    return properties;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x180, %edi            # imm = 0x180
movl $0x1, %esi
callq *0x17128(%rip)          # 0x2a220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1310d
movq $0x0, -0x8(%rbp)
jmp 0x1318a
movq -0x10(%rbp), %rdi
leaq 0x17120(%rip), %rsi     # 0x2a238
movl $0x180, %edx            # imm = 0x180
callq 0x71d0
callq 0x161d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jne 0x13156
movq -0x10(%rbp), %rdi
callq 0x133c0
movq $0x0, -0x8(%rbp)
jmp 0x1318a
movq -0x10(%rbp), %rax
movq 0x18bf7(%rip), %rcx     # 0x2bd58
movq %rcx, 0x168(%rax)
movq 0x18bf1(%rip), %rcx     # 0x2bd60
movq %rcx, 0x170(%rax)
movl 0x18bec(%rip), %ecx     # 0x2bd68
movl %ecx, 0x178(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: ft_destroy_table
void ft_destroy_table(ft_table_t *table)
{
    size_t i = 0;

    if (table == NULL)
        return;

    if (table->rows) {
        size_t row_n = vector_size(table->rows);
        for (i = 0; i < row_n; ++i) {
            destroy_row(VECTOR_AT(table->rows, i, f_row_t *));
        }
        destroy_vector(table->rows);
    }
    if (table->separators) {
        size_t row_n = vector_size(table->separators);
        for (i = 0; i < row_n; ++i) {
            destroy_separator(VECTOR_AT(table->separators, i, f_separator_t *));
        }
        destroy_vector(table->separators);
    }
    destroy_table_properties(table->properties);
    destroy_string_buffer(table->conv_buffer);
    F_FREE(table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x131c0
jmp 0x132a7
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1321e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x13212
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13350
movq (%rax), %rdi
callq 0x13300
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x131e2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13080
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x13280
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x132b0
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x13273
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13350
movq (%rax), %rdi
callq 0x133a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x13242
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x13080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x133c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13410
movq 0x16f87(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: destroy_row
FT_INTERNAL
void destroy_row(f_row_t *row)
{
    if (row == NULL)
        return;

    if (row->cells) {
        destroy_each_cell(row->cells);
        destroy_vector(row->cells);
    }

    F_FREE(row);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13315
jmp 0x13344
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13337
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x16fa0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13080
movq 0x16eea(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: destroy_table_properties
FT_INTERNAL
void destroy_table_properties(f_table_properties_t *properties)
{
    if (properties == NULL)
        return;

    if (properties->cell_properties != NULL) {
        destroy_cell_prop_container(properties->cell_properties);
    }
    F_FREE(properties);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x133d5
jmp 0x13400
movq -0x8(%rbp), %rax
cmpq $0x0, 0x160(%rax)
je 0x133f3
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x1e270
movq 0x16e2e(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: destroy_string_buffer
FT_INTERNAL
void destroy_string_buffer(f_string_buffer_t *buffer)
{
    if (buffer == NULL)
        return;
    F_FREE(buffer->str.data);
    buffer->str.data = NULL;
    F_FREE(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13425
jmp 0x1344d
movq 0x16dfc(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq 0x16de1(%rip), %rax     # 0x2a228
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: copy_row
FT_INTERNAL
f_row_t *copy_row(f_row_t *row)
{
    assert(row);
    f_row_t *result = create_row();
    if (result == NULL)
        return NULL;

    size_t i = 0;
    size_t cols_n = vector_size(row->cells);
    for (i = 0; i < cols_n; ++i) {
        f_cell_t *cell = VECTOR_AT(row->cells, i, f_cell_t *);
        f_cell_t *new_cell = copy_cell(cell);
        if (new_cell == NULL) {
            destroy_row(result);
            return NULL;
        }
        vector_push(result->cells, &new_cell);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13645
jmp 0x13664
leaq 0x101f8(%rip), %rdi     # 0x23844
leaq 0xf543(%rip), %rsi      # 0x22b96
movl $0x14d9, %edx           # imm = 0x14D9
leaq 0x10f44(%rip), %rcx     # 0x245a3
callq 0x7120
callq 0x171f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13681
movq $0x0, -0x8(%rbp)
jmp 0x1370f
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x132b0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x13707
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13350
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1e350
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x136e9
movq -0x18(%rbp), %rdi
callq 0x13300
movq $0x0, -0x8(%rbp)
jmp 0x1370f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13720
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x136a1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: vector_push
FT_INTERNAL
int vector_push(f_vector_t *vector, const void *item)
{
    assert(vector);
    assert(item);

    if (vector->m_size == vector->m_capacity) {
        if (vector_reallocate_(vector, vector->m_capacity * 2) == -1)
            return FT_GEN_ERROR;
        vector->m_capacity = vector->m_capacity * 2;
    }

    size_t offset = vector->m_size * vector->m_item_size;
    memcpy((char *)vector->m_data + offset, item, vector->m_item_size);

    ++(vector->m_size);

    return FT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13739
jmp 0x13758
leaq 0x101f1(%rip), %rdi     # 0x23931
leaq 0xf44f(%rip), %rsi      # 0x22b96
movl $0x1c84, %edx           # imm = 0x1C84
leaq 0x10fe3(%rip), %rcx     # 0x24736
callq 0x7120
cmpq $0x0, -0x18(%rbp)
je 0x13761
jmp 0x13780
leaq 0xcb07(%rip), %rdi      # 0x2026f
leaq 0xf427(%rip), %rsi      # 0x22b96
movl $0x1c85, %edx           # imm = 0x1C85
leaq 0x10fbb(%rip), %rcx     # 0x24736
callq 0x7120
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x137c6
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq %rsi
callq 0x189d0
cmpl $-0x1, %eax
jne 0x137b3
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1380c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x71d0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
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/neosploit[P]compiler/libfort/lib/fort.c
// Function: copy_table_properties
FT_INTERNAL
f_table_properties_t *copy_table_properties(const f_table_properties_t *properties)
{
    f_table_properties_t *new_opt = create_table_properties();
    if (new_opt == NULL)
        return NULL;

    destroy_vector(new_opt->cell_properties);
    new_opt->cell_properties = copy_cell_properties(properties->cell_properties);
    if (new_opt->cell_properties == NULL) {
        destroy_table_properties(new_opt);
        return NULL;
    }

    memcpy(&new_opt->border_style, &properties->border_style, sizeof(struct fort_border_style));
    memcpy(&new_opt->entire_table_properties,
           &properties->entire_table_properties, sizeof(fort_entire_table_properties_t));

    return new_opt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x130e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13899
movq $0x0, -0x8(%rbp)
jmp 0x13932
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x13080
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x1e2a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jne 0x138e8
movq -0x18(%rbp), %rdi
callq 0x133c0
movq $0x0, -0x8(%rbp)
jmp 0x13932
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x160, %edx            # imm = 0x160
callq 0x71d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x168(%rcx), %rdx
movq %rdx, 0x168(%rax)
movq 0x170(%rcx), %rdx
movq %rdx, 0x170(%rax)
movl 0x178(%rcx), %ecx
movl %ecx, 0x178(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)