LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cck_verify_ssid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string cck_verify_ssid(string ssid){
    string username;
    vector<string> zztmp = cc_split(ssid, string("|"));
    if (zztmp.size() != 2) return username;

    username = zztmp[0];
    string _ssid = cck_create_ssid(username);

    return (_ssid == ssid) ? username : "";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x68017(%rip), %rsi     # 0x776c9
leaq 0x68011(%rip), %rdx     # 0x776ca
leaq 0x28(%rsp), %rdi
callq 0xedfa
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0xf87f
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xf6e4
callq 0xc640
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jne 0xf77f
leaq 0x8(%rsp), %rdi
callq 0xcc40
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x12396
movq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xf51c
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0xf743
callq 0xc640
movq 0x30(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xf764
testq %rdx, %rdx
je 0xf7c3
movq (%r14), %rsi
movq 0x28(%rsp), %rdi
callq 0xc7c0
testl %eax, %eax
je 0xf7c3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x69ef5(%rip), %rdx     # 0x79667
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xedfa
jmp 0xf7df
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
je 0xf79e
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0xf7a5
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
jmp 0xf7ee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x12396
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xf7ee
callq 0xc640
leaq 0x48(%rsp), %rdi
callq 0x11c3c
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf807
callq 0xc640
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xf81d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0xf839
jmp 0xf845
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0xf845
callq 0xc640
jmp 0xf845
jmp 0xf842
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11c3c
jmp 0xf868
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xf868
callq 0xc640
jmp 0xf868
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf877
callq 0xc640
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> cc_split(const string &s, const string &seperator){
    vector<string> result;
    typedef string::size_type string_size;
    string_size i = 0;

    while (i != s.size()){
        int flag = 0;
        while (i != s.size() && flag == 0){
            flag = 1;
            for (string_size x = 0; x < seperator.size(); ++x)
                if (s[i] == seperator[x]){
                    ++i;
                    flag = 0;
                    break;
                }
        }

        flag = 0;
        string_size j = i;
        while (j != s.size() && flag == 0){
            for (string_size x = 0; x < seperator.size(); ++x)
                if (s[j] == seperator[x]){
                    flag = 1;
                    break;
                }
            if (flag == 0)
                ++j;
        }
        if (i != j){
            result.push_back(s.substr(i, j - i));
            i = j;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xf9a3
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movq 0x8(%r14), %rsi
movq (%r15), %rdi
movq %rbp, %rdx
testq %rsi, %rsi
je 0xf8df
movb (%rdi,%rdx), %r8b
xorl %r9d, %r9d
cmpb (%rcx,%r9), %r8b
je 0xf8e4
incq %r9
cmpq %r9, %rsi
jne 0xf8d1
xorl %r8d, %r8d
jmp 0xf8ea
incq %rdx
movb $0x1, %r8b
cmpq %rax, %rdx
je 0xf8f4
testb %r8b, %r8b
jne 0xf8c5
movq %rdx, %rbp
cmpq %rax, %rdx
je 0xf95f
movq (%r14), %rcx
movq 0x8(%r14), %rsi
testq %rsi, %rsi
sete %dil
movq (%r15), %r8
movq %rdx, %rbp
testq %rsi, %rsi
je 0xf947
movb (%r8,%rbp), %r10b
cmpb (%rcx), %r10b
setne %r9b
je 0xf94a
movl $0x1, %r13d
movq %r13, %r11
cmpq %r13, %rsi
je 0xf93e
leaq 0x1(%r11), %r13
cmpb (%rcx,%r11), %r10b
setne %r9b
jne 0xf928
cmpq %rsi, %r11
setae %r10b
jmp 0xf94d
movb $0x1, %r9b
movl %edi, %r10d
movzbl %r10b, %r10d
addq %r10, %rbp
testb $0x1, %r9b
je 0xf95f
cmpq %rax, %rbp
jne 0xf910
movq %rbp, %rcx
subq %rdx, %rcx
jne 0xf96c
movq %rdx, %rbp
jmp 0xf996
movq %r12, %rdi
movq %r15, %rsi
callq 0xcb00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12826
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf996
callq 0xc640
movq 0x8(%r15), %rax
cmpq %rax, %rbp
jne 0xf8b8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf9d1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf9d1
callq 0xc640
movq %rbx, %rdi
callq 0x11c3c
movq %r14, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_valid_image_ext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string cc_valid_image_ext(string name){
    string ext = "";
    if (cc_ends_with(name, ".jpg"))
        ext = ".jpg";
    else if (cc_ends_with(name, ".gif"))
        ext = ".gif";
    else if (cc_ends_with(name, ".png"))
        ext = ".png";

    return ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x69c0f(%rip), %rdx     # 0x79667
movq %rdx, %rsi
callq 0xedfa
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x63933(%rip), %r14     # 0x733a3
leaq 0x63930(%rip), %rdx     # 0x733a7
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xedfa
movq 0x8(%r15), %rsi
movq 0x10(%rsp), %rdx
subq %rdx, %rsi
jae 0xfa96
xorl %ebp, %ebp
jmp 0xfaa9
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0xcbf0
testl %eax, %eax
sete %bpl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfab8
callq 0xc640
testb %bpl, %bpl
jne 0xfb6f
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x638d8(%rip), %r14     # 0x733a8
leaq 0x638d5(%rip), %rdx     # 0x733ac
movq %r14, %rsi
callq 0xedfa
movq 0x8(%r15), %rsi
movq 0x10(%rsp), %rdx
subq %rdx, %rsi
jae 0xfaf1
xorl %ebp, %ebp
jmp 0xfb04
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0xcbf0
testl %eax, %eax
sete %bpl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfb13
callq 0xc640
testb %bpl, %bpl
jne 0xfb6f
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x63886(%rip), %r14     # 0x733ad
leaq 0x63883(%rip), %rdx     # 0x733b1
movq %r14, %rsi
callq 0xedfa
movq 0x8(%r15), %rsi
movq 0x10(%rsp), %rdx
subq %rdx, %rsi
jae 0xfb48
xorl %ebp, %ebp
jmp 0xfb5b
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0xcbf0
testl %eax, %eax
sete %bpl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfb6a
callq 0xc640
testb %bpl, %bpl
je 0xfb86
movq 0x8(%rbx), %rdx
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xc5c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfba0
jmp 0xfbb6
jmp 0xfba0
jmp 0xfbb6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfbb9
callq 0xc640
jmp 0xfbb9
jmp 0xfbb6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xfbc6
callq 0xc640
movq %r14, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_ends_with(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool cc_ends_with(std::string const &fullString, std::string const &ending) {
    if (fullString.length() >= ending.length()) {
        return (0 == fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
    }
    else {
        return false;
    }
}

// Assembly:
movq %rsi, %rcx
movq 0x8(%rdi), %rsi
movq 0x8(%rcx), %rdx
subq %rdx, %rsi
jae 0xfbe1
xorl %eax, %eax
retq
pushq %rax
callq 0xcbf0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_random_chars[abi:cxx11](int)
string cc_random_chars(int len){
    char *username = new char[len + 1];
    unqlite_util_random_string(pDb, username, len);
    username[len] = 0;

    string ret(username);

    delete [] username;

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %eax
cmpl $-0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovgel %eax, %ecx
movslq %ecx, %rdi
callq 0xc560
movq %rax, %r15
leaq 0x86fdb(%rip), %rax     # 0x96bf8
movq (%rax), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x33572
movslq %r14d, %rax
movb $0x0, (%r15,%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xc460
leaq (%rax,%r15), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xedfa
movq %r15, %rdi
callq 0xc400
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_timestamp_to_time[abi:cxx11](long)
string cc_timestamp_to_time(time_t ts){
    struct tm tm_date;

    localtime_r(&(ts), &tm_date);

    char std_time[64];
    strftime(std_time, 64, "%X", &tm_date);

    string ret(std_time);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
leaq 0x58(%rsp), %r14
movq %r14, %rsi
callq 0xc1e0
leaq 0x6371b(%rip), %rdx     # 0x733bb
leaq 0x10(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
movq %r14, %rcx
callq 0xc9d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xc460
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xedfa
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_timestamp_diff_day(long, long)
int cc_timestamp_diff_day(time_t t1, time_t t2){
    struct tm tm_t1, tm_t2;
    localtime_r(&t1, &tm_t1);
    localtime_r(&t2, &tm_t2);

    time_t diff = t1 - (tm_t1.tm_sec + tm_t1.tm_min * 60 + tm_t1.tm_hour * 3600) -
                  (t2 - (tm_t2.tm_sec + tm_t2.tm_min * 60 + tm_t2.tm_hour * 3600));
    
    return (int)(diff / 3600 / 24);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
leaq 0x8(%rsp), %rbx
movq %rsi, (%rbx)
leaq 0x50(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc1e0
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc1e0
movq (%r14), %rax
movslq (%r15), %rcx
movslq 0x4(%r15), %rdx
imulq $0x3c, %rdx, %rdx
addq %rcx, %rdx
movslq 0x8(%r15), %rcx
imulq $0xe10, %rcx, %rcx      # imm = 0xE10
addq %rdx, %rcx
movslq (%r12), %rdx
movslq 0x4(%r12), %rsi
imulq $0x3c, %rsi, %rsi
addq %rdx, %rsi
movslq 0x8(%r12), %rdx
imulq $0xe10, %rdx, %rdx      # imm = 0xE10
addq %rsi, %rdx
addq (%rbx), %rcx
subq %rcx, %rax
addq %rdx, %rax
movabsq $0x1845c8a0ce512957, %rcx # imm = 0x1845C8A0CE512957
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0xd, %rdx
addl %edx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: logLog(char const*, ...)
void logLog(const char* msg, ...){
    time_t rawtime;
    time(&rawtime);

    char timetmp[64];
    struct tm * timeinfo;
    timeinfo = localtime(&(rawtime));

    strftime(timetmp, 64, "%Y/%m/%d %X", timeinfo);

    fprintf(log_file, "[%s]\t", timetmp);

    va_list argptr;
    va_start(argptr, msg);
    vfprintf(log_file, msg, argptr);
    va_end(argptr);

    fprintf(log_file, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0xfe03
movaps %xmm0, 0xa0(%rsp)
movaps %xmm1, 0xb0(%rsp)
movaps %xmm2, 0xc0(%rsp)
movaps %xmm3, 0xd0(%rsp)
movaps %xmm4, 0xe0(%rsp)
movaps %xmm5, 0xf0(%rsp)
movaps %xmm6, 0x100(%rsp)
movaps %xmm7, 0x110(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc820
movq %r14, %rdi
callq 0xc770
leaq 0x63593(%rip), %rdx     # 0x733b2
leaq 0x30(%rsp), %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0xc9d0
leaq 0x86e3d(%rip), %r12     # 0x96c78
movq (%r12), %rdi
leaq 0x63578(%rip), %rsi     # 0x733be
movq %r14, %rdx
xorl %eax, %eax
callq 0xc260
leaq 0x10(%rsp), %rdx
movq %r15, 0x10(%rdx)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r12), %rdi
movq %rbx, %rsi
callq 0xcba0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xc970
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: database_fatal(char const*)
void database_fatal(const char *zMsg){
    if (pDb){
        const char *zErr;
        int iLen = 0; /* Stupid cc warning */

        /* Extract the database error log */
        unqlite_config(pDb, UNQLITE_CONFIG_ERR_LOG, &zErr, &iLen);
        if (iLen > 0){
            /* Output the DB error log */
            puts(zErr); /* Always null termniated */
        }
    }
    else{
        if (zMsg){
            puts(zMsg);
        }
    }
    /* Manually shutdown the library */
    unqlite_lib_shutdown();
    /* Exit immediately */
    exit(0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x86d51(%rip), %rax     # 0x96bf8
movq (%rax), %rax
testq %rax, %rax
jne 0xfeb6
testq %rdi, %rdi
jne 0xfedf
jmp 0xfee4
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movq %rsp, %rdx
movq %rax, %rdi
movl $0x3, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2ebc2
cmpl $0x0, (%rbx)
jle 0xfee4
movq (%rsp), %rdi
callq 0xcb40
callq 0x2deeb
xorl %edi, %edi
callq 0xc7a0
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_smart_shorten(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
string cc_smart_shorten(string& s, int limiter){
    //s = s.substr(0, limiter * 2);
    int nl_pos = s.find_first_of("<");
    s = s.substr(0, nl_pos);
    if(s.size() <= limiter) return s;

    string ret = s.substr(0, limiter);
    if(nl_pos <= limiter) return ret;

    for(int i = limiter; i < s.size(); ++i){
        if(i < s.size() - 3){
            if(s[i] == -17 && s[i+1] == -68 && s[i+2] == -116) break;
            if(s[i] == -29 && s[i+1] == -128 && s[i+2] == -126) break;
            if(s[i] == ',' || s[i] == '.') break;
        }
        ret += s[i];
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x677a5(%rip), %rsi     # 0x776b0
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0xc230
movq %rax, %r12
movslq %r12d, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xcb00
movq %r14, %rdi
movq %r15, %rsi
callq 0xc5e0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xff4d
callq 0xc640
movq 0x8(%r14), %rdx
movslq %ebp, %r15
cmpq %r15, %rdx
jbe 0xffff
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xcb00
cmpl %r15d, %r12d
jle 0x10014
movq 0x8(%r14), %rax
cmpq %r15, %rax
jbe 0x10014
xorl %ebp, %ebp
addq $-0x3, %rax
cmpq %r15, %rax
jbe 0xffe1
movq (%r14), %rcx
movzbl (%rcx,%r15), %eax
cmpl $0xee, %eax
jle 0xffb4
cmpl $0xef, %eax
jne 0xffe1
cmpb $-0x44, 0x1(%rcx,%r15)
jne 0xffb4
cmpb $-0x74, 0x2(%rcx,%r15)
je 0x10014
cmpl $0xe3, %eax
jne 0xffd2
cmpb 0x1(%rcx,%r15), %bpl
jno 0xffd9
andb $-0x3, %al
cmpb $0x2c, %al
je 0x10014
cmpb $-0x7e, 0x2(%rcx,%r15)
jne 0xffe1
jmp 0x10014
cmpl $0x2c, %eax
jne 0xffdc
jmp 0x10014
orl $0x2, %eax
cmpl $0x2e, %eax
je 0x10014
movq (%r14), %rax
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0xccc0
incq %r15
movq 0x8(%r14), %rax
cmpq %r15, %rax
ja 0xff85
jmp 0x10014
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x12396
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x10038
callq 0xc640
movq %r14, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string cc_replace(std::string str, const std::string& from, const std::string& to) {
    size_t start_pos = 0;
    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
    }
    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc3e0
cmpq $-0x1, %rax
je 0x11116
movq %rax, %r13
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc200
addq 0x8(%r15), %r13
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0xc3e0
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x110de
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x11135
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x1113b
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_extract_uri_num(mg_connection*)
int cc_extract_uri_num(mg_connection* conn){
    string url(conn->uri);
    vector<string> tmp = cc_split(url, "/");
    string num = tmp[tmp.size() - 1];

    return atol(num.c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq 0x8(%rdi), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xcae0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6a3ff(%rip), %rsi     # 0x7b5ac
leaq 0x6a3f9(%rip), %rdx     # 0x7b5ad
leaq 0x8(%rsp), %rdi
callq 0xedfa
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf87f
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x111e1
callq 0xc640
movq 0x30(%rsp), %rax
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x12396
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc710
movq %rax, %rbx
cmpq %r15, %r14
je 0x1121b
movq %r14, %rdi
callq 0xc640
leaq 0x28(%rsp), %rdi
callq 0x11c3c
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11238
callq 0xc640
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11c3c
jmp 0x1126a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1126a
callq 0xc640
jmp 0x1126a
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1127d
callq 0xc640
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/helper.cpp
// Function: cc_load_file_to_set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void cc_load_file_to_set(const string& p, unordered_set<string>& s){
    ifstream f(p);
    string line;
    while (f >> line) if(line != "") s.insert(line);
    f.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0xcbc0
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x10(%rsp), %r15
leaq 0x67bc7(%rip), %r12     # 0x79667
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0xc4e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11ae2
movq %r15, %rdi
movq %r12, %rsi
callq 0xca10
testl %eax, %eax
je 0x11aa5
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x12a88
jmp 0x11aa5
leaq 0x30(%rsp), %rdi
callq 0xc730
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x11afb
callq 0xc640
leaq 0x30(%rsp), %rdi
callq 0xc060
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11b19
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x11b2b
callq 0xc640
leaq 0x30(%rsp), %rdi
callq 0xc060
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/router.h
// Function: route::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void add(const std::string pattern, int no){
        // "/page/:num"
        std::vector<std::string> v = cc_split(pattern, "/");
        struct Tree *top = root;

        for(auto i: v)
            if(!i.empty()){
                if(i[0] == ':'){
                    top->catcher = i.substr(1);
                }else{
                    if(!top->to[i]) top->to[i] = new Tree();
                    top = top->to[i];
                }
            }

        top->ending = no;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x686c9(%rip), %rsi     # 0x7b5ac
leaq 0x686c3(%rip), %rdx     # 0x7b5ad
leaq 0x10(%rsp), %rdi
callq 0xedfa
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0xf87f
movl %ebx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x12f19
callq 0xc640
movq 0x83c28(%rip), %r14     # 0x96b48
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r12
cmpq %r12, %rbx
je 0x13046
leaq 0x10(%rsp), %r15
movq %rbp, 0x10(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x12396
cmpq $0x0, 0x18(%rsp)
je 0x1302a
movq 0x10(%rsp), %rax
cmpb $0x3a, (%rax)
jne 0x12faa
movl $0x1, %edx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0xcb00
leaq 0x30(%r14), %rdi
movq %r13, %rsi
callq 0xc5e0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1302a
callq 0xc640
jmp 0x1302a
movq %r14, %rdi
movq %r15, %rsi
callq 0x18336
cmpq $0x0, (%rax)
jne 0x1301c
movl $0x58, %edi
callq 0xc1d0
movq %rax, %r13
addq $0x8, %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x30(%r13)
movaps %xmm0, 0x40(%r13)
movaps %xmm0, (%r13)
xorl %edx, %edx
movq %rdx, 0x50(%r13)
movq %r13, %rcx
addq $0x40, %rcx
movq %rax, 0x18(%r13)
movq %rax, 0x20(%r13)
movq %rdx, 0x28(%r13)
movq %rcx, 0x30(%r13)
movq %rdx, 0x38(%r13)
movb $0x0, 0x40(%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0x18336
movq %r13, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x18336
movq (%rax), %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13039
callq 0xc640
addq $0x20, %rbx
cmpq %r12, %rbx
jne 0x12f38
movl 0xc(%rsp), %eax
movl %eax, 0x50(%r14)
leaq 0x30(%rsp), %rdi
callq 0x11c3c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x130a3
callq 0xc640
jmp 0x130a3
movq %rax, %rbx
jmp 0x130a3
jmp 0x13082
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13099
callq 0xc640
jmp 0x13099
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x11c3c
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/config.h
// Function: bool ConfigManager::get<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T get(const std::string& k){
		if(typeid(T).name() == typeid(int).name())
			return configs_int[k];
		else if(typeid(T).name() == typeid(bool).name())
			return configs_bool[k];
		else
			return 0;
	}

// Assembly:
pushq %rax
movq 0x7db80(%rip), %rax     # 0x95fe8
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpb $0x2a, (%rax)
sete %cl
addq %rax, %rcx
movq 0x7db2a(%rip), %rax     # 0x95fa8
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpb $0x2a, (%rax)
sete %dl
addq %rax, %rdx
cmpq %rdx, %rcx
je 0x1849f
addq $0x70, %rdi
callq 0x1df40
movb (%rax), %al
jmp 0x184ae
addq $0x38, %rdi
callq 0x12426
cmpl $0x0, (%rax)
setne %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/config.h
// Function: ConfigManager::try_set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ConfigManager& try_set(const std::string& k, const std::string& v){
		if(v == "on" || v == "off")
			configs_bool[k] = (v == "on");
		else{
			if(configs_str.find(k) != configs_str.end())
				configs_str[k] = v;
			else if(configs_int.find(k) != configs_int.end())
				configs_int[k] = atol(v.c_str());
		}
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x62346(%rip), %rsi     # 0x7a914
movq %rdx, %rdi
callq 0xca10
testl %eax, %eax
je 0x18615
leaq 0x5b688(%rip), %rsi     # 0x73c69
movq %r15, %rdi
callq 0xca10
testl %eax, %eax
je 0x18615
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e33e
testq %rax, %rax
je 0x18643
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11ee8
movq %rax, %rdi
movq %r15, %rsi
callq 0xcc40
jmp 0x18637
leaq 0x622f8(%rip), %rsi     # 0x7a914
movq %r15, %rdi
callq 0xca10
movl %eax, %ebp
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1df40
testl %ebp, %ebp
sete (%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1e378
testq %rax, %rax
je 0x18637
movq (%r15), %rdi
callq 0xc710
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x12426
movl %r15d, (%rax)
jmp 0x18637
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/config.h
// Function: ConfigManager::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string trim(const std::string& str){
		std::string::size_type pos = str.find_first_not_of(' ');
		if (pos == std::string::npos)
		{
			return str;
		}
		std::string::size_type pos2 = str.find_last_not_of(' ');
		if (pos2 != std::string::npos)
		{
			return str.substr(pos, pos2 - pos + 1);
		}
		return str.substr(pos);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xc9e0
cmpq $-0x1, %rax
je 0x1e4b5
movq %rax, %r15
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0xc780
cmpq $-0x1, %rax
je 0x1e4d0
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x1e4e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x12396
jmp 0x1e4e5
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0xcb00
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/tags.h
// Function: HTMLTemplate::load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void load_file(string s) {
		std::ifstream ifs(s);
		string line, sz;
		while (getline(ifs, line)) sz += trim(line);

		load(sz);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rdi, %rbx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0xcbc0
leaq 0x50(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %rbp
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x80(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xcb80
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xc030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1eb0e
movq %r12, %rdi
movq %r15, %rsi
callq 0x1ebf6
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r13, %rdi
callq 0xc830
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1eaab
callq 0xc640
jmp 0x1eaab
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x12396
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ec80
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x1eb49
callq 0xc640
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1eb5c
callq 0xc640
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1eb70
callq 0xc640
leaq 0x80(%rsp), %rdi
callq 0xc060
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
jne 0x1ebad
jmp 0x1ebb9
jmp 0x1ebb6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ebb9
callq 0xc640
jmp 0x1ebb9
jmp 0x1ebb6
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1ebcc
callq 0xc640
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1ebe0
callq 0xc640
leaq 0x80(%rsp), %rdi
callq 0xc060
movq %rbx, %rdi
callq 0xc760
nop
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/tags.h
// Function: HTMLTemplate::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static string trim(const string& str)
	{
		string::size_type pos = str.find_first_not_of(' ');
		if (pos == string::npos)
		{
			return str;
		}
		string::size_type pos2 = str.find_last_not_of(' ');
		if (pos2 != string::npos)
		{
			return str.substr(pos, pos2 - pos + 1);
		}
		return str.substr(pos);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xc9e0
cmpq $-0x1, %rax
je 0x1ec47
movq %rax, %r15
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0xc780
cmpq $-0x1, %rax
je 0x1ec62
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x1ec72
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x12396
jmp 0x1ec77
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0xcb00
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/views/list/gallery.cpp
// Function: views::gallery::showGallery(mg_connection*, int, int)
void showGallery(mg_connection* conn, cclong startID, cclong endID){
            struct Thread *r = unq_read_thread(pDb, 0); // get the root thread
            cclong c = 0;

            bool admin_view = is_admin(conn);

            cclong totalThreads = r->childCount;
            // cclong totalPages = 100;

            templates.invoke("site_slogan").pipe_to(conn).destory();

            for(cclong i = totalThreads; i > 0; --i){
                delete r;
                r = unq_read_thread(pDb, i);
                if(strlen(r->imgSrc) == 15 && r->state & NORMAL_DISPLAY) {
                    c++;
                    if (c >= startID && c <= endID){
                        mg_printf_data(conn, "<hr>");
                        views::each_thread(conn, r, SEND_SHOW_REPLY_LINK + SEND_CUT_LONG_COMMENT, admin_view);
                    }
                }
                
                if (c == endID + 1) break;
            }
            if(r) delete r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %r14
leaq 0x70d97(%rip), %rbp     # 0x96bf8
movq (%rbp), %rdi
xorl %esi, %esi
callq 0xe181
movq %rax, %r15
movq %r14, %rdi
callq 0xef24
movb %al, (%rsp)
movl 0xcc(%r15), %r12d
leaq 0x28(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x4e246(%rip), %rsi     # 0x740d7
leaq 0x4e24a(%rip), %rdx     # 0x740e2
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0xedfa
leaq 0x70e7c(%rip), %rdi     # 0x96d28
movq %r13, %rsi
callq 0x1852c
movq %rax, %rdi
movq %r14, %rsi
callq 0x18672
movq %rax, %r13
movq %rax, %rdi
callq 0x1a17a
movq %r13, %rdi
callq 0xc640
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x25ee1
callq 0xc640
testl %r12d, %r12d
jle 0x25f99
movq 0x10(%rsp), %rax
leal 0x1(%rax), %r13d
movzbl (%rsp), %eax
movl %eax, 0x8(%rsp)
xorl %ebx, %ebx
movq %r14, (%rsp)
testq %r15, %r15
je 0x25f0e
movq %r15, %rdi
callq 0xc640
movq (%rbp), %rdi
movl %r12d, %esi
callq 0xe181
movq %rax, %r15
leaq 0xa8(%rax), %rdi
callq 0xc460
cmpq $0xf, %rax
jne 0x25f82
testb $0x1, (%r15)
je 0x25f82
leal 0x1(%rbx), %r14d
cmpl 0xc(%rsp), %r14d
setl %al
cmpl 0x10(%rsp), %ebx
setge %cl
orb %al, %cl
jne 0x25f7f
movq (%rsp), %rbx
movq %rbx, %rdi
leaq 0x4e152(%rip), %rsi     # 0x740ac
xorl %eax, %eax
callq 0x6a0f7
movq %rbx, %rdi
movq %r15, %rsi
movl $0x6, %edx
movl 0x8(%rsp), %ecx
leaq 0x536f0(%rip), %r8      # 0x79667
movq %r8, %r9
callq 0x2331c
movl %r14d, %ebx
cmpl %r13d, %ebx
je 0x25f99
leal -0x1(%r12), %eax
cmpl $0x1, %r12d
movl %eax, %r12d
jg 0x25f01
testq %r15, %r15
je 0x25fa6
movq %r15, %rdi
callq 0xc640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x25fc7
callq 0xc640
movq %r14, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/actions/chat.cpp
// Function: websocket::poll(mg_connection*)
void poll(mg_connection *conn) {
        if(!conn->connection_param) return;

        struct ChatData *d = (struct ChatData *) conn->connection_param;

        string username = cck_verify_ssid(d->ssid);
        if(username.empty()) return;

        struct mg_connection *c;

        if (conn->content_len > 5 && !memcmp(conn->content, "join ", 5)) {
        // Client joined new room
            d->roomID = conn->content[5];
        } else if (conn->content_len > 4 && !memcmp(conn->content, "msg ", 4) &&
                 d->roomID != 0 && d->roomID != '?') {
            broadcast(conn);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq 0x290(%rdi), %r12
testq %r12, %r12
je 0x2aa33
movq %rdi, %rbx
leaq 0x4(%r12), %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r14, %rdi
callq 0xc460
leaq (%r12,%rax), %rdx
addq $0x4, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xedfa
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xf676
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2a9be
callq 0xc640
cmpq $0x0, 0x28(%rsp)
je 0x2aa20
movq 0x270(%rbx), %rax
cmpq $0x6, %rax
jb 0x2a9ec
movq 0x268(%rbx), %rcx
movl $0x6e696f6a, %edx       # imm = 0x6E696F6A
xorl (%rcx), %edx
movzbl 0x4(%rcx), %esi
xorl $0x20, %esi
orl %edx, %esi
je 0x2aa18
cmpq $0x5, %rax
jb 0x2aa20
movq 0x268(%rbx), %rax
cmpl $0x2067736d, (%rax)     # imm = 0x2067736D
jne 0x2aa20
movl (%r12), %eax
testl %eax, %eax
je 0x2aa20
cmpl $0x3f, %eax
je 0x2aa20
movq %rbx, %rdi
callq 0x2a678
jmp 0x2aa20
movsbl 0x5(%rcx), %eax
movl %eax, (%r12)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2aa33
callq 0xc640
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2aa60
jmp 0x2aa65
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2aa65
callq 0xc640
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./src/actions/kill.cpp
// Function: actions::kill::call(mg_connection*, int, bool)
bool call(mg_connection* conn, int tid, bool admin){
            string username = cck_verify_ssid(conn);
            bool flag = false;

            if (!username.empty()){
                struct Thread* t = unq_read_thread(pDb, tid);

                if (strcmp(t->ssid, username.c_str()) == 0 || admin){
                    unq_delete_thread(pDb, tid);
                    logLog("%s has deleted No.%d", username.c_str(), tid);
                    flag = true;
                }
                else{
                    flag = false;
                }

                if(t) delete t;
            }else
                flag = false;

            return flag;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xf5d8
cmpq $0x0, 0x8(%rbx)
je 0x2b2e6
leaq 0x6b96b(%rip), %r12     # 0x96bf8
movq (%r12), %rdi
movl %ebp, %esi
callq 0xe181
movq %rax, %r14
leaq 0x91(%rax), %rdi
movq (%rsp), %rsi
callq 0xc950
testl %eax, %eax
sete %bl
orb %r15b, %bl
cmpb $0x1, %bl
jne 0x2b2d7
movq (%r12), %rdi
movl %ebp, %esi
callq 0xe1e4
movq (%rsp), %rsi
leaq 0x48f8a(%rip), %rdi     # 0x74258
movl %ebp, %edx
xorl %eax, %eax
callq 0xfd95
testq %r14, %r14
je 0x2b2e8
movq %r14, %rdi
callq 0xc640
jmp 0x2b2e8
xorl %ebx, %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2fb
callq 0xc640
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b320
callq 0xc640
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_lib_shutdown
int unqlite_lib_shutdown(void)
{
	if( sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC ){
		/* Already shut */
		return UNQLITE_OK;
	}
	unqliteCoreShutdown();
	return UNQLITE_OK;
}

// Assembly:
cmpl $0xea1495ba, 0x688e3(%rip) # imm = 0xEA1495BA
jne 0x2e073
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x688c0(%rip)     # 0x967c8
jle 0x2df34
movq 0x688bf(%rip), %rdi     # 0x967d0
movq 0x110(%rdi), %rbx
callq 0x2f024
movl 0x688a5(%rip), %eax     # 0x967c8
leal -0x1(%rax), %ecx
movl %ecx, 0x6889c(%rip)     # 0x967c8
movq %rbx, %rdi
cmpl $0x1, %eax
jg 0x2df11
leaq 0x68855(%rip), %rdi     # 0x96790
callq 0x3a2bc
movq 0x68831(%rip), %rax     # 0x96778
testq %rax, %rax
je 0x2df8b
movq 0x6882d(%rip), %rdi     # 0x96780
testq %rdi, %rdi
je 0x2df6e
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2df63
callq *%rax
movq $0x0, 0x68812(%rip) # 0x96780
movq 0x68803(%rip), %rax     # 0x96778
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2df80
callq *%rax
movq $0x0, 0x687ed(%rip) # 0x96778
movl $0x0, 0x687f3(%rip)     # 0x96788
cmpq $0x0, 0x6872b(%rip)     # 0x966c8
je 0x2dfab
leaq 0x6871a(%rip), %rdi     # 0x966c0
callq 0x2ea67
movl $0x1764, 0x68823(%rip)  # imm = 0x1764
cmpl $0xea1495ba, 0x69111(%rip) # imm = 0xEA1495BA
jne 0x2e06d
cmpl $0x0, 0x690f4(%rip)     # 0x970c0
jle 0x2dff8
movq 0x690f3(%rip), %rdi     # 0x970c8
movq 0x108(%rdi), %rbx
callq 0x3a2f2
movl 0x690d9(%rip), %eax     # 0x970c0
leal -0x1(%rax), %ecx
movl %ecx, 0x690d0(%rip)     # 0x970c0
movq %rbx, %rdi
cmpl $0x1, %eax
jg 0x2dfd5
movq 0x690a1(%rip), %rax     # 0x970a0
testq %rax, %rax
je 0x2e043
movq 0x6909d(%rip), %rdi     # 0x970a8
testq %rdi, %rdi
je 0x2e026
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2e01b
callq *%rax
movq $0x0, 0x69082(%rip) # 0x970a8
movq 0x69073(%rip), %rax     # 0x970a0
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2e038
callq *%rax
movq $0x0, 0x6905d(%rip) # 0x970a0
movl $0x0, 0x69063(%rip)     # 0x970b0
cmpq $0x0, 0x68f9b(%rip)     # 0x96ff0
je 0x2e063
leaq 0x68f8a(%rip), %rdi     # 0x96fe8
callq 0x2ea67
movl $0x1928, 0x69063(%rip)  # imm = 0x1928
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendPoolAlloc
JX9_PRIVATE void * SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
	void *pChunk;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return 0;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	pChunk = MemBackendPoolAlloc(&(*pBackend), nByte);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return pChunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2e975
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2e975
callq *0x20(%rax)
movl %r14d, %esi
addq $0x8, %rsi
cmpl $0x7ff7, %r14d          # imm = 0x7FF7
jbe 0x2e9a4
movq %rbx, %rdi
callq 0x33c19
testq %rax, %rax
je 0x2ea42
movq %rax, %r14
movl $0xdeadffff, (%rax)     # imm = 0xDEADFFFF
jmp 0x2ea3c
testl %r14d, %r14d
je 0x2e9ba
movl $0x8, %ecx
xorl %eax, %eax
addl %ecx, %ecx
incl %eax
cmpl %esi, %ecx
jb 0x2e9b0
jmp 0x2e9bc
xorl %eax, %eax
movl %eax, %r15d
movq 0x40(%rbx,%r15,8), %r14
testq %r14, %r14
jne 0x2ea2a
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x33c19
testq %rax, %rax
je 0x2ea11
leal 0x3(%r15), %ecx
movl $0x1, %edx
shll %cl, %edx
movq %rax, 0x40(%rbx,%r15,8)
cmpl $0xe, %ecx
ja 0x2ea16
xorl %ecx, %ecx
movq %rdx, %rsi
leaq (%rax,%rsi), %rdi
movq %rdi, (%rax,%rcx)
addq %rdx, %rsi
addq %rdx, %rcx
cmpq $0x8000, %rsi           # imm = 0x8000
jb 0x2e9f5
addq %rax, %rcx
jmp 0x2ea19
xorl %r14d, %r14d
jmp 0x2ea25
movq %rax, %rcx
movq $0x0, (%rcx)
movq 0x40(%rbx,%r15,8), %r14
testq %rax, %rax
je 0x2ea42
movq (%r14), %rax
movq %rax, 0x40(%rbx,%r15,8)
orl $0xdead0000, %r15d      # imm = 0xDEAD0000
movl %r15d, (%r14)
addq $0x8, %r14
jmp 0x2ea45
xorl %r14d, %r14d
movq (%rbx), %rax
testq %rax, %rax
je 0x2ea59
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2ea59
callq *0x30(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendRelease
JX9_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend)
{
	sxi32 rc;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return SXERR_INVALID;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	rc = MemBackendRelease(&(*pBackend));
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
		SyMutexRelease(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2ea88
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2ea88
callq *0x20(%rax)
cmpl $0x0, 0x18(%rbx)
je 0x2eada
movq 0x10(%rbx), %r14
movq (%r14), %r15
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x2eada
movq (%r15), %r14
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x2eada
movq (%r14), %r15
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x2eada
movq (%r15), %r14
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
jne 0x2ea92
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rcx
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x2eaf1
movq 0x30(%rcx), %rdi
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0x2eb2d
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2eb0c
callq *0x30(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2eb2d
movq (%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2eb2d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendPoolFree
JX9_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void * pChunk)
{
	sxi32 rc;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) || pChunk == 0 ){
		return SXERR_CORRUPT;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	rc = MemBackendPoolFree(&(*pBackend), pChunk);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2eb5c
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2eb5c
callq *0x20(%rax)
movl -0x8(%r14), %eax
movl %eax, %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
movl $0xffffffe8, %r15d      # imm = 0xFFFFFFE8
cmpl $0xdead0000, %ecx       # imm = 0xDEAD0000
jne 0x2eba0
addq $-0x8, %r14
cmpw $-0x1, %ax
jne 0x2eb8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3508d
jmp 0x2eb9d
andl $0xf, %eax
movq 0x40(%rbx,%rax,8), %rcx
movq %rcx, (%r14)
movq %r14, 0x40(%rbx,%rax,8)
xorl %r15d, %r15d
movq (%rbx), %rax
testq %rax, %rax
je 0x2ebb4
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2ebb4
callq *0x30(%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq