LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: cck_create_ssid[abi:cxx11](char const*)
string cck_create_ssid(const char* username){
    // char newssid[33];
    // strcpy(newssid, to_ssid(username));

    string appender = __generate_appender(username);

    char finalssid[64];// = new char[64];

    int len = sprintf(finalssid, "%s|%s", username, appender.c_str());
    finalssid[len] = 0;

    std::string ret(finalssid);

    return ret;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10740
movq 0x10(%rsp), %rdi
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xd190
movq 0x18(%rsp), %rdx
movq %rax, %rcx
leaq 0xae900(%rip), %rsi     # 0xbf2c4
xorl %eax, %eax
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdd00
movl %eax, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
movb $0x0, 0x50(%rsp,%rax)
movb $0x0, 0x4b(%rsp)
leaq 0x4a(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xdc30
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xdad0
jmp 0x10a0d
leaq 0x4a(%rsp), %rdi
callq 0xdf30
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x10a56
jmp 0x10a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4a(%rsp), %rdi
callq 0xdf30
leaq 0x98(%rsp), %rdi
callq 0xdf50
jmp 0x10a70
movq 0x20(%rsp), %rdi
callq 0xdf50
leaq 0x98(%rsp), %rdi
callq 0xdf50
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xd8a0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xf8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xd480
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdc30
movq 0x28(%rsp), %rdx
leaq 0xb2fc1(%rip), %rsi     # 0xc3bb5
leaq 0x90(%rsp), %rdi
callq 0xdad0
jmp 0x10c03
movq 0x10(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x10e50
jmp 0x10c1f
leaq 0x90(%rsp), %rdi
callq 0xdf50
leaq 0x8f(%rsp), %rdi
callq 0xdf30
leaq 0xb0(%rsp), %rdi
callq 0x148f0
cmpq $0x2, %rax
je 0x10cae
movq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xdbc0
movl $0x1, 0x78(%rsp)
jmp 0x10dfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x10c9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xdf50
leaq 0x8f(%rsp), %rdi
callq 0xdf30
jmp 0x10e31
xorl %eax, %eax
movl %eax, %esi
leaq 0xb0(%rsp), %rdi
callq 0x14910
movq %rax, %rsi
leaq 0xc8(%rsp), %rdi
callq 0xde60
jmp 0x10cd1
leaq 0x38(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xd1b0
jmp 0x10ce5
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x10a80
jmp 0x10cf6
leaq 0x38(%rsp), %rdi
callq 0xdf50
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x14500
movb $0x0, 0x36(%rsp)
testb $0x1, %al
jne 0x10d1a
jmp 0x10d30
movq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xd1b0
jmp 0x10d2e
jmp 0x10d5e
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdc30
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movb $0x1, 0x36(%rsp)
leaq 0xb4df6(%rip), %rsi     # 0xc5b4b
callq 0xdad0
jmp 0x10d5c
jmp 0x10d5e
testb $0x1, 0x36(%rsp)
jne 0x10d67
jmp 0x10d71
leaq 0x37(%rsp), %rdi
callq 0xdf30
movl $0x1, 0x78(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xdf50
jmp 0x10dfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x10e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdf50
jmp 0x10e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x10df1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
testb $0x1, 0x36(%rsp)
jne 0x10de5
jmp 0x10def
leaq 0x37(%rsp), %rdi
callq 0xdf30
jmp 0x10df1
leaq 0x58(%rsp), %rdi
callq 0xdf50
jmp 0x10e24
leaq 0xb0(%rsp), %rdi
callq 0x14930
leaq 0xc8(%rsp), %rdi
callq 0xdf50
movq 0x20(%rsp), %rax
addq $0xf8, %rsp
retq
leaq 0xb0(%rsp), %rdi
callq 0x14930
leaq 0xc8(%rsp), %rdi
callq 0xdf50
movq 0x80(%rsp), %rdi
callq 0xd8a0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd7b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd7b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x11657
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd7b0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xd7b0
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd7b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
callq 0xdd80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x1165c
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
incl %eax
movslq %eax, %rdi
testq %rdi, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0xd650
movq %rax, 0x40(%rsp)
leaq 0xdd93e(%rip), %rax     # 0xeeff0
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x5a550
movq 0x40(%rsp), %rax
movslq 0x4c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, 0x3f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3e(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdc30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xdad0
jmp 0x11705
leaq 0x3e(%rsp), %rdi
callq 0xdf30
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x11727
movq (%rsp), %rdi
callq 0xd4d0
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x11759
jmp 0x1174f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3e(%rsp), %rdi
callq 0xdf30
jmp 0x11763
movq 0x10(%rsp), %rdi
callq 0xdf50
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd8a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xd260
movq 0x8(%rsp), %rcx
leaq 0xadbac(%rip), %rdx     # 0xbf395
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x40, %esi
callq 0xdb40
movb $0x0, 0x3f(%rsp)
leaq 0x3e(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdc30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xdad0
jmp 0x11827
leaq 0x3e(%rsp), %rdi
callq 0xdf30
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x11863
jmp 0x11859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3e(%rsp), %rdi
callq 0xdf30
jmp 0x1186f
movq 0x10(%rsp), %rdi
callq 0xdf50
movq (%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd8a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd260
leaq 0x78(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd260
movq 0x80(%rsp), %rax
movl 0x40(%rsp), %ecx
imull $0x3c, 0x44(%rsp), %edx
addl %edx, %ecx
imull $0xe10, 0x48(%rsp), %edx # imm = 0xE10
addl %edx, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movq 0x78(%rsp), %rcx
movl 0x8(%rsp), %edx
imull $0x3c, 0xc(%rsp), %esi
addl %esi, %edx
imull $0xe10, 0x10(%rsp), %esi # imm = 0xE10
addl %esi, %edx
movslq %edx, %rdx
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movl $0x18, %ecx
cqto
idivq %rcx
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x148, %rsp            # imm = 0x148
testb %al, %al
je 0x11962
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x140(%rsp)
leaq 0x138(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd980
movq (%rsp), %rdi
callq 0xd8b0
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rcx
leaq 0xad9d8(%rip), %rdx     # 0xbf38c
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x40, %esi
callq 0xdb40
movq 0x8(%rsp), %rdx
leaq 0xdd699(%rip), %rax     # 0xef070
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
leaq 0xad9b2(%rip), %rsi     # 0xbf398
xorl %eax, %eax
movb %al, 0x1f(%rsp)
callq 0xd2d0
movq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0xe0(%rsp)
leaq 0x150(%rsp), %rcx
movq %rcx, 0xd8(%rsp)
movl $0x30, 0xd4(%rsp)
movl $0x8, 0xd0(%rsp)
movq (%rax), %rdi
movq 0x140(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0xdd30
movq 0x10(%rsp), %rcx
movb 0x1f(%rsp), %al
movq (%rcx), %rdi
leaq 0xb5185(%rip), %rsi     # 0xc6bd9
callq 0xd2d0
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xdd570(%rip), %rax     # 0xeeff0
cmpq $0x0, (%rax)
je 0x11ac1
movl $0x0, 0x4(%rsp)
leaq 0xdd55b(%rip), %rax     # 0xeeff0
movq (%rax), %rdi
movl $0x3, %esi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movb $0x0, %al
callq 0x54520
cmpl $0x0, 0x4(%rsp)
jle 0x11abf
movq 0x8(%rsp), %rdi
callq 0xdce0
jmp 0x11ad5
cmpq $0x0, 0x10(%rsp)
je 0x11ad3
movq 0x10(%rsp), %rdi
callq 0xdce0
jmp 0x11ad5
callq 0x53e50
xorl %edi, %edi
callq 0xd8f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd890
movq %rax, 0x20(%rsp)
cmpq $-0x1, %rax
je 0x13571
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0xd7b0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
movq 0x28(%rsp), %rcx
callq 0xdc40
movq 0x28(%rsp), %rdi
callq 0xd7b0
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13513
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xdbc0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: startsWith(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 startsWith(std::string const &fullString, std::string const &start) {
    if (fullString.length() >= start.length()) {
        return (0 == fullString.compare(0, start.length(), start));
    }
    else {
        return false;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd7b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd7b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x135fd
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xd7b0
movq (%rsp), %rdi
movq %rax, %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0xdd80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x13602
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdc30
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0xdad0
jmp 0x1365b
leaq 0x9f(%rsp), %rdi
callq 0xdf30
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdc30
movq 0x10(%rsp), %rdx
leaq 0xb4829(%rip), %rsi     # 0xc7eac
leaq 0x50(%rsp), %rdi
callq 0xdad0
jmp 0x1368f
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x10e50
jmp 0x136a8
leaq 0x50(%rsp), %rdi
callq 0xdf50
leaq 0x4f(%rsp), %rdi
callq 0xdf30
leaq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x148f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x14910
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0xd1b0
jmp 0x136ea
leaq 0x28(%rsp), %rdi
callq 0xd190
movq %rax, %rdi
callq 0xd840
movl %eax, 0x4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdf50
leaq 0x70(%rsp), %rdi
callq 0x14930
leaq 0xa0(%rsp), %rdi
callq 0xdf50
movl 0x4(%rsp), %eax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0xdf30
jmp 0x137bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdf50
leaq 0x4f(%rsp), %rdi
callq 0xdf30
jmp 0x137ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x14930
leaq 0xa0(%rsp), %rdi
callq 0xdf50
movq 0x90(%rsp), %rdi
callq 0xd8a0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq 0x270(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0xdd50
leaq 0x40(%rsp), %rdi
callq 0xd480
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd5d0
movq %rax, 0x18(%rsp)
jmp 0x1433e
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xd4c0
movb %al, 0x17(%rsp)
jmp 0x14358
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x14362
jmp 0x143dd
leaq 0xb17e2(%rip), %rsi     # 0xc5b4b
leaq 0x40(%rsp), %rdi
callq 0x14d80
movb %al, 0x16(%rsp)
jmp 0x14379
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x14383
jmp 0x143d8
movq 0x268(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x14db0
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x143a0
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
jmp 0x143d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdf50
leaq 0x60(%rsp), %rdi
callq 0xd080
jmp 0x14405
jmp 0x14328
leaq 0x60(%rsp), %rdi
callq 0xd860
jmp 0x143e9
leaq 0x40(%rsp), %rdi
callq 0xdf50
leaq 0x60(%rsp), %rdi
callq 0xd080
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x38(%rsp), %rdi
callq 0xd8a0
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/config.h
// Function: int ConfigManager::get<int>(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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd9861(%rip), %rdi     # 0xedfa0
callq 0x177a0
movq %rax, 0x18(%rsp)
movq 0xd9850(%rip), %rdi     # 0xedfa0
callq 0x177a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x1477d
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
callq 0x177f0
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x147cf
movq 0xd981c(%rip), %rdi     # 0xedfa0
callq 0x177a0
movq %rax, 0x8(%rsp)
movq 0xd984b(%rip), %rdi     # 0xedfe0
callq 0x177a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x147c7
movq 0x10(%rsp), %rdi
addq $0x70, %rdi
movq 0x20(%rsp), %rsi
callq 0x17820
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0x147cf
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xa33d2(%rip), %rsi     # 0xc71fb
callq 0x19c90
testb $0x1, %al
jne 0x23e49
movq 0x40(%rsp), %rdi
leaq 0x9bdc3(%rip), %rsi     # 0xbfc01
callq 0x19c90
testb $0x1, %al
jne 0x23e49
jmp 0x23e7f
movq 0x40(%rsp), %rdi
leaq 0xa33a6(%rip), %rsi     # 0xc71fb
callq 0x19c90
movq 0x18(%rsp), %rdi
movb %al, 0x17(%rsp)
addq $0x70, %rdi
movq 0x48(%rsp), %rsi
callq 0x17820
movb 0x17(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x23f52
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x348b0
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x348e0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x34890
testb $0x1, %al
jne 0x23eb7
jmp 0x23edf
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0x160e0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xde60
jmp 0x23f50
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movq 0x48(%rsp), %rsi
callq 0x34930
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x38, %rdi
callq 0x34960
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x34910
testb $0x1, %al
jne 0x23f1f
jmp 0x23f4e
movq 0x40(%rsp), %rdi
callq 0xd190
movq %rax, %rdi
callq 0xd840
movq 0x18(%rsp), %rdi
movl %eax, 0x4(%rsp)
addq $0x38, %rdi
movq 0x48(%rsp), %rsi
callq 0x177f0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x23f50
jmp 0x23f52
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/tags.h
// Function: TemplateManager::add_template(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
HTMLTemplate& add_template(const string& name){
		HTMLTemplate tmp;
		std::string root_dir = "./templates/" + lang + "/";

		tmp.load_file(root_dir + name + string(".tpl"));

		m_templates[name] = tmp;

		return m_templates[name]; //*this;
	}

// Assembly:
subq $0x318, %rsp            # imm = 0x318
movq %rdi, 0x310(%rsp)
movq %rsi, 0x308(%rsp)
movq 0x310(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x29b00
movq 0x20(%rsp), %rdx
addq $0x30, %rdx
leaq 0x9a66a(%rip), %rsi     # 0xbfc8b
leaq 0xa0(%rsp), %rdi
callq 0x149e0
jmp 0x25630
leaq 0xa2875(%rip), %rdx     # 0xc7eac
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x147e0
jmp 0x2564e
leaq 0xa0(%rsp), %rdi
callq 0xdf50
movq 0x308(%rsp), %rdx
leaq 0x50(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x35350
jmp 0x25677
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdc30
movq 0x18(%rsp), %rdx
leaq 0x9a692(%rip), %rsi     # 0xbfd24
leaq 0x30(%rsp), %rdi
callq 0xdad0
jmp 0x2569e
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x14b10
jmp 0x256b4
leaq 0xe0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x35fd0
jmp 0x256c8
leaq 0x70(%rsp), %rdi
callq 0xdf50
leaq 0x30(%rsp), %rdi
callq 0xdf50
leaq 0x2f(%rsp), %rdi
callq 0xdf30
leaq 0x50(%rsp), %rdi
callq 0xdf50
movq 0x20(%rsp), %rdi
movq 0x308(%rsp), %rsi
callq 0x28b20
movq %rax, 0x10(%rsp)
jmp 0x25709
movq 0x10(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x36160
jmp 0x2571d
movq 0x20(%rsp), %rdi
movq 0x308(%rsp), %rsi
callq 0x28b20
movq %rax, 0x8(%rsp)
jmp 0x25736
leaq 0xc0(%rsp), %rdi
callq 0xdf50
leaq 0xe0(%rsp), %rdi
callq 0x26f60
movq 0x8(%rsp), %rax
addq $0x318, %rsp            # imm = 0x318
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x25827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xdf50
jmp 0x25827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x2581a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x25806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x257fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xdf50
leaq 0x30(%rsp), %rdi
callq 0xdf50
leaq 0x2f(%rsp), %rdi
callq 0xdf30
leaq 0x50(%rsp), %rdi
callq 0xdf50
leaq 0xc0(%rsp), %rdi
callq 0xdf50
leaq 0xe0(%rsp), %rdi
callq 0x26f60
movq 0x98(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xdb50
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0x351fc
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xd1b0
jmp 0x3525e
movq 0x28(%rsp), %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0xd8c0
movq %rax, 0x18(%rsp)
cmpq $-0x1, 0x18(%rsp)
je 0x35243
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
addq $0x1, %rcx
callq 0xdca0
jmp 0x3525e
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq $-0x1, %rcx
callq 0xdca0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq 0x2c0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xb0(%rsp), %rdi
movl $0x8, %edx
callq 0xdd50
leaq 0x90(%rsp), %rdi
callq 0xd480
leaq 0x70(%rsp), %rdi
callq 0xd480
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xd6d0
movq %rax, 0x10(%rsp)
jmp 0x36039
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xd4c0
movb %al, 0xf(%rsp)
jmp 0x36053
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3605d
jmp 0x360bb
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x362a0
jmp 0x36071
leaq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd120
jmp 0x36082
leaq 0x40(%rsp), %rdi
callq 0xdf50
jmp 0x3601d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x3612b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdf50
jmp 0x3612b
leaq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xd1b0
jmp 0x360cc
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x36360
jmp 0x360dd
leaq 0x20(%rsp), %rdi
callq 0xdf50
leaq 0x70(%rsp), %rdi
callq 0xdf50
leaq 0x90(%rsp), %rdi
callq 0xdf50
leaq 0xb0(%rsp), %rdi
callq 0xd080
addq $0x2c8, %rsp            # imm = 0x2C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xdf50
leaq 0x70(%rsp), %rdi
callq 0xdf50
leaq 0x90(%rsp), %rdi
callq 0xdf50
leaq 0xb0(%rsp), %rdi
callq 0xd080
movq 0x68(%rsp), %rdi
callq 0xd8a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xdb50
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0x362ec
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xd1b0
jmp 0x3634e
movq 0x28(%rsp), %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0xd8c0
movq %rax, 0x18(%rsp)
cmpq $-0x1, 0x18(%rsp)
je 0x36333
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
addq $0x1, %rcx
callq 0xdca0
jmp 0x3634e
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq $-0x1, %rcx
callq 0xdca0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq $0x0, 0x290(%rax)
jne 0x4dd96
jmp 0x4df2f
movq 0x80(%rsp), %rax
movq 0x290(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdc30
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0xdad0
jmp 0x4dddd
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x10ba0
jmp 0x4ddee
leaq 0x38(%rsp), %rdi
callq 0xdf50
leaq 0x37(%rsp), %rdi
callq 0xdf30
leaq 0x58(%rsp), %rdi
callq 0xd3f0
testb $0x1, %al
jne 0x4de12
jmp 0x4de56
movl $0x1, 0x20(%rsp)
jmp 0x4df25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x4de47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdf50
leaq 0x37(%rsp), %rdi
callq 0xdf30
jmp 0x4df37
movq 0x80(%rsp), %rax
cmpq $0x5, 0x270(%rax)
jbe 0x4dea9
movq 0x80(%rsp), %rax
movq 0x268(%rax), %rdi
leaq 0x7234b(%rip), %rsi     # 0xc01c9
movl $0x5, %edx
callq 0xddb0
cmpl $0x0, %eax
jne 0x4dea9
movq 0x80(%rsp), %rax
movq 0x268(%rax), %rax
movsbl 0x5(%rax), %ecx
movq 0x78(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4df1d
movq 0x80(%rsp), %rax
cmpq $0x4, 0x270(%rax)
jbe 0x4df1b
movq 0x80(%rsp), %rax
movq 0x268(%rax), %rax
movl (%rax), %eax
subl $0x2067736d, %eax       # imm = 0x2067736D
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4df1b
movq 0x78(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4df1b
movq 0x78(%rsp), %rax
cmpl $0x3f, (%rax)
je 0x4df1b
movq 0x80(%rsp), %rdi
callq 0x4d9a0
jmp 0x4deff
jmp 0x4df1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xdf50
jmp 0x4df37
jmp 0x4df1d
movl $0x0, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xdf50
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movb %dl, %al
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
andb $0x1, %al
movb %al, 0x6b(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x10af0
movb $0x0, 0x47(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd3f0
testb $0x1, %al
jne 0x4fa94
leaq 0x9f62e(%rip), %rax     # 0xeeff0
movq (%rax), %rdi
movl 0x6c(%rsp), %esi
callq 0xea50
movq %rax, 0x20(%rsp)
jmp 0x4f9d5
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x91, %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd190
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xdab0
cmpl $0x0, %eax
je 0x4fa12
testb $0x1, 0x6b(%rsp)
je 0x4fa69
leaq 0x9f5d7(%rip), %rax     # 0xeeff0
movq (%rax), %rdi
movl 0x6c(%rsp), %esi
callq 0xead0
jmp 0x4fa27
leaq 0x48(%rsp), %rdi
callq 0xd190
movq %rax, %rsi
movl 0x6c(%rsp), %edx
leaq 0x707d9(%rip), %rdi     # 0xc0218
xorl %eax, %eax
callq 0x11920
jmp 0x4fa48
movb $0x1, 0x47(%rsp)
jmp 0x4fa6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdf50
jmp 0x4fab6
movb $0x0, 0x47(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x4fa92
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x4fa90
movq 0x10(%rsp), %rdi
callq 0xd760
jmp 0x4fa92
jmp 0x4fa99
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
movb %al, 0xf(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdf50
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd8a0
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_lib_config
int unqlite_lib_config(int nConfigOp,...)
{
	va_list ap;
	int rc;
	if( sUnqlMPGlobal.nMagic == UNQLITE_LIB_MAGIC ){
		/* Library is already initialized, this operation is forbidden */
		return UNQLITE_LOCKED;
	}
	va_start(ap,nConfigOp);
	rc = unqliteCoreConfigure(nConfigOp,ap);
	va_end(ap);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x53628
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movl %edi, -0x8(%rbp)
cmpl $0xea1495ba, 0x9b280(%rip) # imm = 0xEA1495BA
jne 0x53663
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x536a0
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x536b0
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0xea1495ba, 0x9aa76(%rip) # imm = 0xEA1495BA
je 0x53e6d
movl $0x0, -0x4(%rbp)
jmp 0x53e79
callq 0x53e90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCoreShutdown
static void unqliteCoreShutdown(void)
{
	unqlite *pDb, *pNext;
	/* Release all active databases handles */
	pDb = sUnqlMPGlobal.pDB;
	for(;;){
		if( sUnqlMPGlobal.nDB < 1 ){
			break;
		}
		pNext = pDb->pNext;
		unqliteDbRelease(pDb); 
		pDb = pNext;
		sUnqlMPGlobal.nDB--;
	}
	/* Release the storage methods container */
	SySetRelease(&sUnqlMPGlobal.kv_storage);
#if defined(UNQLITE_ENABLE_THREADS)
	/* Release the mutex subsystem */
	if( sUnqlMPGlobal.pMutexMethods ){
		if( sUnqlMPGlobal.pMutex ){
			SyMutexRelease(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex);
			sUnqlMPGlobal.pMutex = 0;
		}
		if( sUnqlMPGlobal.pMutexMethods->xGlobalRelease ){
			sUnqlMPGlobal.pMutexMethods->xGlobalRelease();
		}
		sUnqlMPGlobal.pMutexMethods = 0;
	}
	sUnqlMPGlobal.nThreadingLevel = 0;
#endif
	if( sUnqlMPGlobal.sAllocator.pMethods ){
		/* Release the memory backend */
		SyMemBackendRelease(&sUnqlMPGlobal.sAllocator);
	}
	sUnqlMPGlobal.nMagic = 0x1764;
	/* Finally, shutdown the Jx9 library */
	jx9_lib_shutdown();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9aa31(%rip), %rax     # 0xee8d0
movq %rax, -0x8(%rbp)
cmpl $0x1, 0x9aa1e(%rip)     # 0xee8c8
jge 0x53eae
jmp 0x53edf
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x54ad0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl 0x9a9f4(%rip), %eax     # 0xee8c8
addl $-0x1, %eax
movl %eax, 0x9a9eb(%rip)     # 0xee8c8
jmp 0x53ea3
leaq 0x9a8da(%rip), %rdi     # 0xee7c0
addq $0xd0, %rdi
callq 0x66980
cmpq $0x0, 0x9a97e(%rip)     # 0xee878
je 0x53f60
cmpq $0x0, 0x9a97c(%rip)     # 0xee880
je 0x53f3d
cmpq $0x0, 0x9a972(%rip)     # 0xee880
je 0x53f32
movq 0x9a961(%rip), %rax     # 0xee878
cmpq $0x0, 0x18(%rax)
je 0x53f32
movq 0x9a953(%rip), %rax     # 0xee878
movq 0x18(%rax), %rax
movq 0x9a950(%rip), %rdi     # 0xee880
callq *%rax
movq $0x0, 0x9a943(%rip) # 0xee880
movq 0x9a934(%rip), %rax     # 0xee878
cmpq $0x0, 0x8(%rax)
je 0x53f55
movq 0x9a926(%rip), %rax     # 0xee878
callq *0x8(%rax)
movq $0x0, 0x9a918(%rip) # 0xee878
movl $0x0, 0x9a91e(%rip)     # 0xee888
cmpq $0x0, 0x9a856(%rip)     # 0xee7c8
je 0x53f80
leaq 0x9a845(%rip), %rdi     # 0xee7c0
callq 0x543e0
movl $0x1764, 0x9a94e(%rip)  # imm = 0x1764
callq 0x669f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5422b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54229
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x5422b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xac320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54267
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54265
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x54267
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyZero
JX9_PRIVATE void SyZero(void *pSrc, sxu32 nSize)
{
	register unsigned char *zSrc = (unsigned char *)pSrc;
	unsigned char *zEnd;
#if defined(UNTRUST)
	if( zSrc == 0 || nSize <= 0 ){
		return ;
	}
#endif
	zEnd = &zSrc[nSize];
	for(;;){
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x542ad
jmp 0x5431f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x542cc
jmp 0x5431f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x542eb
jmp 0x5431f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x5430a
jmp 0x5431f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x542a1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteInitDatabase
static int unqliteInitDatabase(
	unqlite *pDB,            /* Database handle */
	SyMemBackend *pParent,   /* Master memory backend */
	const char *zFilename,   /* Target database */
	unsigned int iFlags      /* Open flags */
	)
{
	unqlite_db *pStorage = &pDB->sDB;
	int rc;
	/* Initialiaze the memory subsystem */
	SyMemBackendInitFromParent(&pDB->sMem,pParent);
#if defined(UNQLITE_ENABLE_THREADS)
	/* No need for internal mutexes */
	SyMemBackendDisbaleMutexing(&pDB->sMem);
#endif
	SyBlobInit(&pDB->sErr,&pDB->sMem);	
	/* Sanityze flags */
	iFlags = unqliteSanityzeFlag(iFlags);
	/* Init the pager and the transaction manager */
	rc = unqlitePagerOpen(sUnqlMPGlobal.pVfs,pDB,zFilename,iFlags);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Allocate a new Jx9 engine handle */
	rc = jx9_init(&pStorage->pJx9);
	if( rc != JX9_OK ){
		return rc;
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60230
movq -0x10(%rbp), %rdi
callq 0x602f0
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0x58bb0
movl -0x24(%rbp), %edi
callq 0x66bd0
movl %eax, -0x24(%rbp)
movq 0x9a52f(%rip), %rdi     # 0xee8c0
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x66c60
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x543b2
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x543d7
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x67080
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x543d0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x543d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54418
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54416
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x54418
movq -0x8(%rbp), %rdi
callq 0xac5b0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5447e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x5444e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x5447c
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x5447c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x5447e
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x544cc
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x544ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x544cc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xac510
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54508
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54506
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
jmp 0x54508
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_config
int unqlite_config(unqlite *pDb,int nConfigOp,...)
{
	va_list ap;
	int rc;
	if( UNQLITE_DB_MISUSE(pDb) ){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire DB mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_DB_RELEASE(pDb) ){
			 return UNQLITE_ABORT; /* Another thread have released this instance */
	 }
#endif
	 va_start(ap, nConfigOp);
	 rc = unqliteConfigure(&(*pDb),nConfigOp, ap);
	 va_end(ap);
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5455b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x54595
movq -0x10(%rbp), %rax
cmpl $0xdb7c2712, 0x120(%rax) # imm = 0xDB7C2712
je 0x545a1
movl $0xffffffe8, -0x4(%rbp) # imm = 0xFFFFFFE8
jmp 0x54650
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0x545c7
movq 0x9a2c2(%rip), %rax     # 0xee878
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rdi
callq *%rax
cmpl $0x1, 0x9a2ba(%rip)     # 0xee888
jbe 0x545e9
movq -0x10(%rbp), %rax
cmpl $0xdb7c2712, 0x120(%rax) # imm = 0xDB7C2712
je 0x545e9
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x54650
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x54660
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0x5464a
movq 0x9a23f(%rip), %rax     # 0xee878
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rdi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)