LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: JianjiaoSQ[P]MyPoorWebServer/http/http_conn.cpp
// Function: http_conn::add_response(char const*, ...)
bool http_conn::add_response(const char *format, ...)
{
    if (m_write_idx >= WRITE_BUFFER_SIZE)
        return false;
    va_list arg_list;
    va_start(arg_list, format);
    int len = vsnprintf(m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list);
    if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_idx))
    {
        va_end(arg_list);
        return false;
    }
    m_write_idx += len;
    va_end(arg_list);

    LOG_INFO("request:%s", m_write_buf);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x676b
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)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
cmpl $0x400, 0xc34(%rax)     # imm = 0x400
jl 0x67af
movb $0x0, -0x1(%rbp)
jmp 0x688d
movq -0xf8(%rbp), %rcx
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rdx
movq %rdx, 0x10(%rax)
leaq 0x10(%rbp), %rdx
movq %rdx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq %rcx, %rdi
addq $0x834, %rdi            # imm = 0x834
movslq 0xc34(%rcx), %rax
addq %rax, %rdi
movl $0x3ff, %eax            # imm = 0x3FF
subl 0xc34(%rcx), %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x32d0
movq -0xf8(%rbp), %rdx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x3ff, %ecx            # imm = 0x3FF
subl 0xc34(%rdx), %ecx
cmpl %ecx, %eax
jl 0x682f
leaq -0x30(%rbp), %rax
movb $0x0, -0x1(%rbp)
jmp 0x688d
movq -0xf8(%rbp), %rcx
movl -0x34(%rbp), %eax
addl 0xc34(%rcx), %eax
movl %eax, 0xc34(%rcx)
leaq -0x30(%rbp), %rax
xorl %eax, %eax
cmpl 0xe34(%rcx), %eax
jne 0x6889
callq 0x6df0
movq -0xf8(%rbp), %rcx
movq %rax, %rdi
addq $0x834, %rcx            # imm = 0x834
movl $0x1, %esi
leaq 0x7ad9(%rip), %rdx      # 0xe34e
movb $0x0, %al
callq 0x9300
callq 0x6df0
movq %rax, %rdi
callq 0x9870
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/http/http_conn.cpp
// Function: http_conn::process()
void http_conn::process()
{
    HTTP_CODE read_ret = process_read();
    if (read_ret == NO_REQUEST)
    {
        modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
        return;
    }
    bool write_ret = process_write(read_ret);
    if (!write_ret)
    {
        close_conn();
    }
    modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5840
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6ce1
movq -0x18(%rbp), %rax
movl 0xd794(%rip), %edi      # 0x14460
movl 0x14(%rax), %esi
movl 0xe30(%rax), %ecx
movl $0x1, %edx
callq 0x4dc0
jmp 0x6d23
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6a50
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x6d06
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4e30
movq -0x18(%rbp), %rax
movl 0xd750(%rip), %edi      # 0x14460
movl 0x14(%rax), %esi
movl 0xe30(%rax), %ecx
movl $0x4, %edx
callq 0x4dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/log/block_queue.h
// Function: block_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::block_queue(int)
block_queue(int max_size = 1000)
    {
        if (max_size <= 0)
        {
            exit(-1);
        }

        m_max_size = max_size;
        m_array = new T[max_size];
        m_size = 0;
        m_front = -1;
        m_back = -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x6d30
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x9cc0
jmp 0x98f6
cmpl $0x0, -0xc(%rbp)
jg 0x9917
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x99e8
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x64(%rax)
movslq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x40(%rbp)
jmp 0x9957
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
cmpq $0x0, %rax
je 0x99ac
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3610
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x998a
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl $0x0, 0x60(%rax)
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x6c(%rax) # imm = 0xFFFFFFFF
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9d20
movq -0x30(%rbp), %rdi
callq 0x6d90
movq -0x18(%rbp), %rdi
callq 0x3710
nopw (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/log/block_queue.h
// Function: block_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::full()
bool full() 
    {
        m_mutex.lock();
        if (m_size >= m_max_size)
        {

            m_mutex.unlock();
            return true;
        }
        m_mutex.unlock();
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x7010
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %eax
cmpl 0x64(%rcx), %eax
jl 0x9a54
movq -0x18(%rbp), %rdi
callq 0x7190
movb $0x1, -0x1(%rbp)
jmp 0x9a61
movq -0x18(%rbp), %rdi
callq 0x7190
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/log/block_queue.h
// Function: block_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const T &item)
    {

        m_mutex.lock();
        if (m_size >= m_max_size)
        {

            m_cond.broadcast();
            m_mutex.unlock();
            return false;
        }

        m_back = (m_back + 1) % m_max_size;
        m_array[m_back] = item;

        m_size++;

        m_cond.broadcast();
        m_mutex.unlock();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7010
movq -0x20(%rbp), %rcx
movl 0x60(%rcx), %eax
cmpl 0x64(%rcx), %eax
jl 0x9ab5
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x9d40
movq -0x20(%rbp), %rdi
callq 0x7190
movb $0x0, -0x1(%rbp)
jmp 0x9b05
movq -0x20(%rbp), %rcx
movl 0x6c(%rcx), %eax
addl $0x1, %eax
cltd
idivl 0x64(%rcx)
movq -0x20(%rbp), %rax
movl %edx, 0x6c(%rax)
movq -0x18(%rbp), %rsi
movq 0x58(%rax), %rdi
movslq 0x6c(%rax), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
movq -0x20(%rbp), %rdi
movl 0x60(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x60(%rdi)
addq $0x28, %rdi
callq 0x9d40
movq -0x20(%rbp), %rdi
callq 0x7190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: JianjiaoSQ[P]MyPoorWebServer/log/log.h
// Function: Log::async_write_log()
void *async_write_log()
    {
        string single_log;
        //从阻塞队列中取出一个日志string，写入文件
        while (m_log_queue->pop(single_log))
        {
            m_mutex.lock();
            fputs(single_log.c_str(), m_fp);
            m_mutex.unlock();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3610
movq -0x40(%rbp), %rax
movq 0x130(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9bc0
movb %al, -0x41(%rbp)
jmp 0x9b46
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x9b4f
jmp 0x9baa
movq -0x40(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x7010
jmp 0x9b61
leaq -0x28(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq 0x120(%rax), %rsi
callq 0x3500
jmp 0x9b7f
movq -0x40(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x7190
jmp 0x9b91
jmp 0x9b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x32c0
jmp 0x9bac
ud2
movq -0x30(%rbp), %rdi
callq 0x3710
nopw %cs:(%rax,%rax)
nop
// File: JianjiaoSQ[P]MyPoorWebServer/log/block_queue.h
// Function: block_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool pop(T &item)
    {

        m_mutex.lock();
        while (m_size <= 0)
        {
            
            if (!m_cond.wait(m_mutex.get()))
            {
                m_mutex.unlock();
                return false;
            }
        }

        m_front = (m_front + 1) % m_max_size;
        item = m_array[m_front];
        m_size--;
        m_mutex.unlock();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7010
movq -0x20(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jg 0x9c1c
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
callq 0x9cb0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9c70
testb $0x1, %al
jne 0x9c1a
movq -0x20(%rbp), %rdi
callq 0x7190
movb $0x0, -0x1(%rbp)
jmp 0x9c5f
jmp 0x9bdd
movq -0x20(%rbp), %rcx
movl 0x68(%rcx), %eax
addl $0x1, %eax
cltd
idivl 0x64(%rcx)
movq -0x20(%rbp), %rax
movl %edx, 0x68(%rax)
movq 0x58(%rax), %rsi
movslq 0x68(%rax), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x3050
movq -0x20(%rbp), %rdi
movl 0x60(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x60(%rdi)
callq 0x7190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/CGImysql/sql_connection_pool.cpp
// Function: connection_pool::GetConnection()
MYSQL *connection_pool::GetConnection()
{
	MYSQL *con = NULL;

	if (0 == connList.size())
		return NULL;

	reserve.wait();
	
	lock.lock();

	con = connList.front();
	connList.pop_front();

	--m_FreeConn;
	++m_CurConn;

	lock.unlock();
	return con;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x38, %rdi
callq 0xa5d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xa169
movq $0x0, -0x8(%rbp)
jmp 0xa1cb
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0xa600
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x7010
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0xa630
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
callq 0xa660
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rdi)
movl 0x4(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x4(%rdi)
addq $0x10, %rdi
callq 0x7190
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/CGImysql/sql_connection_pool.cpp
// Function: connection_pool::ReleaseConnection(MYSQL*)
bool connection_pool::ReleaseConnection(MYSQL *con) 
{
	if (NULL == con)
		return false;

	lock.lock();

	connList.push_back(con); // 连接地址 插入链表；
	++m_FreeConn;
	--m_CurConn;

	lock.unlock();

	reserve.post();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0xa206
movb $0x0, -0x1(%rbp)
jmp 0xa254
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x7010
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa510
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
movl 0x4(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rdi)
addq $0x10, %rdi
callq 0x7190
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0xa690
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: JianjiaoSQ[P]MyPoorWebServer/CGImysql/sql_connection_pool.cpp
// Function: connection_pool::DestroyPool()
void connection_pool::DestroyPool()
{

	lock.lock();
	if (connList.size() > 0)
	{
		list<MYSQL *>::iterator it;
		for (it = connList.begin(); it != connList.end(); ++it)
		{
			MYSQL *con = *it;
			mysql_close(con);
		}
		m_CurConn = 0;
		m_FreeConn = 0;
		connList.clear();
	}

	lock.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x7010
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0xa5d0
cmpq $0x0, %rax
jbe 0xa319
leaq -0x10(%rbp), %rdi
callq 0xa6c0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0xa6e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0xa740
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa710
testb $0x1, %al
jne 0xa2da
jmp 0xa2fe
leaq -0x10(%rbp), %rdi
callq 0xa770
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x35e0
leaq -0x10(%rbp), %rdi
callq 0xa790
jmp 0xa2b6
movq -0x30(%rbp), %rdi
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
addq $0x38, %rdi
callq 0xa7b0
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x7190
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::WebServer()
WebServer::WebServer() {
    //http_conn类对象
    users = new http_conn[MAX_FD];

    //root文件夹路径
    char server_path[200];
    getcwd(server_path, 200);
    char root[6] = "/root";
    m_root = (char *)malloc(strlen(server_path) + strlen(root) + 1);
    strcpy(m_root, server_path);
    strcat(m_root, root);   // 文件地址

    //定时器
    users_timer = new client_data[MAX_FD];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
addq $0x38, %rdi
movq %rdi, -0x110(%rbp)
callq 0x3610
movq -0xf8(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x108(%rbp)
callq 0x3610
movq -0xf8(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x100(%rbp)
callq 0x3610
movq -0xf8(%rbp), %rdi
addq $0x1d588, %rdi          # imm = 0x1D588
movq %rdi, -0xf0(%rbp)
callq 0xc790
jmp 0xaf54
movl $0xf680008, %edi        # imm = 0xF680008
callq 0x3030
movq %rax, -0x118(%rbp)
jmp 0xaf67
movq -0x118(%rbp), %rax
movq $0x10000, (%rax)        # imm = 0x10000
addq $0x8, %rax
movq %rax, -0x130(%rbp)
movq %rax, %rcx
addq $0xf680000, %rcx        # imm = 0xF680000
movq %rcx, -0x128(%rbp)
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0xc7b0
jmp 0xafad
movq -0x128(%rbp), %rcx
movq -0x138(%rbp), %rax
addq $0xf68, %rax            # imm = 0xF68
cmpq %rcx, %rax
movq %rax, -0x120(%rbp)
jne 0xaf98
movq -0xf8(%rbp), %rax
movq -0x130(%rbp), %rcx
movq %rcx, 0x28(%rax)
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movl $0xc8, %esi
callq 0x3230
movq -0x150(%rbp), %rdi
movw $0x74, -0xe4(%rbp)
movl $0x6f6f722f, -0xe8(%rbp) # imm = 0x6F6F722F
callq 0x31b0
movq %rax, -0x158(%rbp)
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x31b0
movq %rax, %rcx
movq -0x158(%rbp), %rax
leaq 0x1(%rax,%rcx), %rdi
callq 0x35d0
movq -0x150(%rbp), %rsi
movq %rax, %rcx
movq -0xf8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x3430
movq -0x148(%rbp), %rsi
movq -0xf8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3730
movl $0x200000, %edi         # imm = 0x200000
callq 0x3030
movq %rax, -0x140(%rbp)
jmp 0xb08c
movq -0xf8(%rbp), %rax
movq -0x140(%rbp), %rcx
movq %rcx, 0x1d580(%rax)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb13e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb132
movq -0x130(%rbp), %rcx
movq %rax, %rsi
movq -0x138(%rbp), %rax
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq %rax, %rcx
movq %rax, -0x160(%rbp)
je 0xb121
movq -0x160(%rbp), %rdi
addq $-0xf68, %rdi           # imm = 0xF098
movq %rdi, -0x168(%rbp)
callq 0xc7e0
movq -0x130(%rbp), %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x160(%rbp)
jne 0xb0ed
movq -0x118(%rbp), %rdi
movl $0xf680008, %esi        # imm = 0xF680008
callq 0x37d0
movq -0xf0(%rbp), %rdi
callq 0xc810
movq -0x100(%rbp), %rdi
callq 0x32c0
movq -0x108(%rbp), %rdi
callq 0x32c0
movq -0x110(%rbp), %rdi
callq 0x32c0
movq -0x10(%rbp), %rdi
callq 0x3710
nopl (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::~WebServer()
WebServer::~WebServer() {
    close(m_epollfd);
    close(m_listenfd);
    close(m_pipefd[1]);
    close(m_pipefd[0]);
    delete[] users;
    delete[] users_timer;
    delete m_pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x24(%rax), %edi
callq 0x37e0
jmp 0xb18e
movq -0x10(%rbp), %rax
movl 0x1d56c(%rax), %edi
callq 0x37e0
jmp 0xb19f
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x37e0
jmp 0xb1ad
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x37e0
jmp 0xb1bb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xb237
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x28(%rbp)
imulq $0xf68, %rax, %rdx      # imm = 0xF68
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x20(%rbp)
je 0xb21f
movq -0x20(%rbp), %rdi
addq $-0xf68, %rdi           # imm = 0xF098
movq %rdi, -0x38(%rbp)
callq 0xc7e0
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0xb1fa
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
imulq $0xf68, %rax, %rsi      # imm = 0xF68
addq $0x8, %rsi
callq 0x37d0
movq -0x10(%rbp), %rax
movq 0x1d580(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xb255
movq -0x40(%rbp), %rdi
callq 0x35c0
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xb281
movq -0x48(%rbp), %rdi
callq 0xc830
movq -0x48(%rbp), %rdi
movl $0x80, %esi
callq 0x3460
movq -0x10(%rbp), %rdi
addq $0x1d588, %rdi          # imm = 0x1D588
callq 0xc810
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x32c0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x32c0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x32c0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x41c0
nopw %cs:(%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::init(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, int, int)
void WebServer::init(int port, string user, string passWord, string databaseName, int log_write, 
                     int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model)
{
    m_port = port;
    m_user = user;
    m_passWord = passWord;
    m_databaseName = databaseName;
    m_sql_num = sql_num;
    m_thread_num = thread_num;
    m_log_write = log_write;
    m_OPT_LINGER = opt_linger;
    m_TRIGMode = trigmode;
    m_close_log = close_log;
    m_actormodel = actor_model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movl %esi, %eax
movq -0x50(%rbp), %rsi
movl 0x38(%rbp), %edx
movl 0x30(%rbp), %edx
movl 0x28(%rbp), %edx
movl 0x20(%rbp), %edx
movl 0x18(%rbp), %edx
movl 0x10(%rbp), %edx
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x38, %rdi
callq 0x3050
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x3050
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x3050
movq -0x38(%rbp), %rax
movl 0x20(%rbp), %ecx
movl %ecx, 0x98(%rax)
movl 0x28(%rbp), %ecx
movl %ecx, 0xa8(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x1d570(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x1d574(%rax)
movl 0x30(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x38(%rbp), %ecx
movl %ecx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::trig_mode()
void WebServer::trig_mode()  {
    //LT + LT
    if (0 == m_TRIGMode)
    {
        m_LISTENTrigmode = 0;
        m_CONNTrigmode = 0;
    }
    //LT + ET
    else if (1 == m_TRIGMode)
    {
        m_LISTENTrigmode = 0;
        m_CONNTrigmode = 1;
    }
    //ET + LT
    else if (2 == m_TRIGMode)
    {
        m_LISTENTrigmode = 1;
        m_CONNTrigmode = 0;
    }
    //ET + ET
    else if (3 == m_TRIGMode)
    {
        m_LISTENTrigmode = 1;
        m_CONNTrigmode = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpl 0x1d574(%rcx), %eax
jne 0xb3c7
movq -0x10(%rbp), %rax
movl $0x0, 0x1d578(%rax)
movl $0x0, 0x1d57c(%rax)
jmp 0xb44c
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpl 0x1d574(%rcx), %eax
jne 0xb3f2
movq -0x10(%rbp), %rax
movl $0x0, 0x1d578(%rax)
movl $0x1, 0x1d57c(%rax)
jmp 0xb44a
movq -0x10(%rbp), %rcx
movl $0x2, %eax
cmpl 0x1d574(%rcx), %eax
jne 0xb41d
movq -0x10(%rbp), %rax
movl $0x1, 0x1d578(%rax)
movl $0x0, 0x1d57c(%rax)
jmp 0xb448
movq -0x10(%rbp), %rcx
movl $0x3, %eax
cmpl 0x1d574(%rcx), %eax
jne 0xb446
movq -0x10(%rbp), %rax
movl $0x1, 0x1d578(%rax)
movl $0x1, 0x1d57c(%rax)
jmp 0xb448
jmp 0xb44a
jmp 0xb44c
popq %rbp
retq
nop
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::log_write()
void WebServer::log_write() {
    // 如果没有关闭日志
    if (0 == m_close_log) {
        //初始化日志
        if (1 == m_log_write)  // 单例模式
            Log::get_instance()->init("./ServerLog", m_close_log, 2000, 800000, 800);
        else
            Log::get_instance()->init("./ServerLog", m_close_log, 2000, 800000, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0xb4d2
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpl 0x10(%rcx), %eax
jne 0xb4a7
callq 0x6df0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x2fda(%rip), %rsi      # 0xe469
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0xc3500, %r8d          # imm = 0xC3500
movl $0x320, %r9d            # imm = 0x320
callq 0x9060
jmp 0xb4d0
callq 0x6df0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x2fac(%rip), %rsi      # 0xe469
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0xc3500, %r8d          # imm = 0xC3500
xorl %r9d, %r9d
callq 0x9060
jmp 0xb4d2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::sql_pool()
void WebServer::sql_pool() {
    //初始化数据库连接池
    m_connPool = connection_pool::GetInstance();
    // MySQL的默认端口号是 3306
    m_connPool->init("localhost", m_user, m_passWord, m_databaseName, 3306, m_sql_num, m_close_log);

    //初始化数据库读取表
    users->initmysql_result(m_connPool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x9e40
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3720
movq -0xa8(%rbp), %rdx
leaq 0x2f3f(%rip), %rsi      # 0xe475
leaq -0x28(%rbp), %rdi
callq 0x3ea0
jmp 0xb541
movq -0xb8(%rbp), %rsi
addq $0x38, %rsi
leaq -0x60(%rbp), %rdi
callq 0x31a0
jmp 0xb557
movq -0xb8(%rbp), %rsi
addq $0x58, %rsi
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0xb56d
movq -0xb8(%rbp), %rsi
addq $0x78, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x31a0
jmp 0xb586
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl 0x14(%rax), %edx
movl 0x98(%rax), %ecx
movq %rsp, %rax
movl %edx, 0x8(%rax)
movl %ecx, (%rax)
leaq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq -0xa0(%rbp), %r8
movl $0xcea, %r9d            # imm = 0xCEA
callq 0x9ed0
jmp 0xb5c5
leaq -0xa0(%rbp), %rdi
callq 0x32c0
leaq -0x80(%rbp), %rdi
callq 0x32c0
leaq -0x60(%rbp), %rdi
callq 0x32c0
leaq -0x28(%rbp), %rdi
callq 0x32c0
leaq -0x29(%rbp), %rdi
callq 0x34a0
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rsi
callq 0x4a20
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb67d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb674
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb66b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb662
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x32c0
leaq -0x80(%rbp), %rdi
callq 0x32c0
leaq -0x60(%rbp), %rdi
callq 0x32c0
leaq -0x28(%rbp), %rdi
callq 0x32c0
leaq -0x29(%rbp), %rdi
callq 0x34a0
movq -0x38(%rbp), %rdi
callq 0x3710
nop
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::deal_timer(tw_timer*, int)
void WebServer::deal_timer(tw_timer *timer, int sockfd) {
    timer->cb_func(&users_timer[sockfd]);
    if (timer) {
        // utils.m_timer_lst.del_timer(timer);
        utils.m_time_wheel.del_timer(timer);
    }

    LOG_INFO("close fd %d", users_timer[sockfd].sockfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1d580(%rcx), %rdi
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rdi
callq *%rax
cmpq $0x0, -0x10(%rbp)
je 0xbdb2
movq -0x20(%rbp), %rdi
addq $0x1d588, %rdi          # imm = 0x1D588
movq -0x10(%rbp), %rsi
callq 0x43d0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0xbdfe
callq 0x6df0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x1d580(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movl $0x1, %esi
leaq 0x2706(%rip), %rdx      # 0xe4f0
movb $0x0, %al
callq 0x9300
callq 0x6df0
movq %rax, %rdi
callq 0x9870
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::dealwithsignal(bool&, bool&)
bool WebServer::dealwithsignal(bool &timeout, bool &stop_server)
{
    int ret = 0;
    int sig;
    char signals[1024];
    ret = recv(m_pipefd[0], signals, sizeof(signals), 0);
    if (ret == -1)
    {
        return false;
    }
    else if (ret == 0)
    {
        return false;
    }
    else
    {
        for (int i = 0; i < ret; ++i)
        {
            switch (signals[i])
            {
            case SIGALRM:
            {
                timeout = true;
                break;
            }
            case SIGTERM:
            {
                stop_server = true;
                break;
            }
            }
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, -0x24(%rbp)
movl 0x1c(%rax), %edi
leaq -0x430(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3130
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xc097
movb $0x0, -0x1(%rbp)
jmp 0xc10c
cmpl $0x0, -0x24(%rbp)
jne 0xc0a3
movb $0x0, -0x1(%rbp)
jmp 0xc10c
movl $0x0, -0x434(%rbp)
movl -0x434(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xc104
movslq -0x434(%rbp), %rax
movsbl -0x430(%rbp,%rax), %eax
movl %eax, -0x438(%rbp)
subl $0xe, %eax
je 0xc0e1
jmp 0xc0d4
movl -0x438(%rbp), %eax
subl $0xf, %eax
je 0xc0ea
jmp 0xc0f1
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0xc0f1
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
jmp 0xc0f3
movl -0x434(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x434(%rbp)
jmp 0xc0ad
jmp 0xc106
jmp 0xc108
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/././threadpool/threadpool.h
// Function: threadpool<http_conn>::append(http_conn*, int)
bool threadpool<T>::append(T *request, int state)
{
    m_queuelocker.lock();
    if (m_workqueue.size() >= m_max_requests)
    {
        m_queuelocker.unlock();
        return false;
    }
    request->m_state = state;
    m_workqueue.push_back(request);
    m_queuelocker.unlock();
    m_queuestat.post();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x7010
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0xd330
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jb 0xcba1
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x7190
movb $0x0, -0x1(%rbp)
jmp 0xcbda
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0xd360
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x7190
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0xa690
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: JianjiaoSQ[P]MyPoorWebServer/././threadpool/threadpool.h
// Function: threadpool<http_conn>::append_p(http_conn*)
bool threadpool<T>::append_p(T *request)
{
    m_queuelocker.lock();
    if (m_workqueue.size() >= m_max_requests)
    {
        m_queuelocker.unlock();
        return false;
    }
    m_workqueue.push_back(request);
    m_queuelocker.unlock();
    m_queuestat.post();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0x7010
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xd330
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jb 0xcc5e
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x7190
movb $0x0, -0x1(%rbp)
jmp 0xcc8d
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0xd360
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x7190
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0xa690
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JianjiaoSQ[P]MyPoorWebServer/config.cpp
// Function: Config::parse_arg(int, char**)
void Config::parse_arg(int argc, char*argv[]){
    int opt;
    const char *str = "p:l:m:o:s:t:c:a:";
    while ((opt = getopt(argc, argv, str)) != -1)
    {
        switch (opt)
        {
        case 'p':
        {
            PORT = atoi(optarg);
            break;
        }
        case 'l':
        {
            LOGWrite = atoi(optarg);
            break;
        }
        case 'm':
        {
            TRIGMode = atoi(optarg);
            break;
        }
        case 'o':
        {
            OPT_LINGER = atoi(optarg);
            break;
        }
        case 's':
        {
            sql_num = atoi(optarg);
            break;
        }
        case 't':
        {
            thread_num = atoi(optarg);
            break;
        }
        case 'c':
        {
            close_log = atoi(optarg);
            break;
        }
        case 'a':
        {
            actor_model = atoi(optarg);
            break;
        }
        default:
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xea2(%rip), %rax       # 0xe5f4
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x30d0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0xd87a
movl -0x1c(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x13, %eax
ja 0xd873
movq -0x38(%rbp), %rax
leaq 0xe12(%rip), %rcx       # 0xe5a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x6816(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xd875
movq 0x67fa(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xd875
movq 0x67dd(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0xd875
movq 0x67c0(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xd875
movq 0x67a6(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0xd875
movq 0x678c(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0xd875
movq 0x6772(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0xd875
movq 0x6758(%rip), %rax      # 0x13fb8
movq (%rax), %rdi
callq 0x3670
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xd875
jmp 0xd875
jmp 0xd756
addq $0x40, %rsp
popq %rbp
retq
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::asString[abi:cxx11]() const
std::string Value::asString() const {
        switch (type) {
        case JSON_NULL: return std::string("null");
        case JSON_TRUE: return std::string("true");
        case JSON_FALSE: return std::string("false");
        case JSON_STRING: return str;
        case JSON_ARRAY: return fw->write(*this);
        case JSON_OBJECT: return fw->write(*this);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x25d1
movq -0x30(%rbp), %rax
leaq 0xab56(%rip), %rcx      # 0xd004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2300
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xaced(%rip), %rsi      # 0xd1c0
callq 0x22a0
jmp 0x24da
leaq -0x11(%rbp), %rdi
callq 0x2240
jmp 0x25d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x2240
jmp 0x25dd
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2300
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xaca7(%rip), %rsi      # 0xd1c5
callq 0x22a0
jmp 0x2525
leaq -0x25(%rbp), %rdi
callq 0x2240
jmp 0x25d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x2240
jmp 0x25dd
leaq -0x26(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2300
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xac61(%rip), %rsi      # 0xd1ca
callq 0x22a0
jmp 0x2570
leaq -0x26(%rbp), %rdi
callq 0x2240
jmp 0x25d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x2240
jmp 0x25dd
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
callq 0x20b0
jmp 0x25d3
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq 0x98(%rdx), %rsi
movq (%rsi), %rax
callq *(%rax)
jmp 0x25d3
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq 0x98(%rdx), %rsi
movq (%rsi), %rax
callq *(%rax)
jmp 0x25d3
ud2
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Reader::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON::Value&)
static int parse(const std::string document, Value& root) {
            json_parser* parser = json_parser::get_parser(document, &root);
            int ret = parser->parse();
            parser = nullptr;
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x39d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a70
movl %eax, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::removeMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value removeMember(const std::string key) {
            std::map<std::string, Value>::iterator mt = object.find(key);
            if (mt != object.end())
                object.erase(mt);
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rsi, %rax
movq -0x58(%rbp), %rsi
movq %rdi, -0x50(%rbp)
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x68, %rdi
callq 0xa600
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x68, %rdi
callq 0xa660
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa630
testb $0x1, %al
jne 0x2fd3
jmp 0x2ff0
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xa690
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x5820
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value& operator[](const std::string key) {
            if (type != JSON_OBJECT)
                clear();
            type = JSON_OBJECT;
            return object[key];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x6, (%rax)
je 0x308a
movq -0x18(%rbp), %rdi
callq 0x3700
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl $0x6, (%rdi)
addq $0x68, %rdi
callq 0xa930
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::append(JSON::Value const&)
void append(const Value& value) {
            switch (type) {
            case JSON_ARRAY:
                array.push_back(value);
                break;
            case JSON_OBJECT:
                assert(value.get_type() == JSON_OBJECT);
                std::vector<std::string> names = value.getMemberNames();
                for (auto vt : names)
                    object.insert(make_pair(vt, value[vt]));
                break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
movl (%rax), %eax
movl %eax, -0x214(%rbp)
subl $0x5, %eax
je 0x318d
jmp 0x317d
movl -0x214(%rbp), %eax
subl $0x6, %eax
je 0x31a6
jmp 0x3395
movq -0x220(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x4e20
jmp 0x3395
movq -0x10(%rbp), %rdi
callq 0x6fc0
cmpl $0x6, %eax
jne 0x31b6
jmp 0x31d5
leaq 0xa328(%rip), %rdi      # 0xd4e5
leaq 0xa1ec(%rip), %rsi      # 0xd3b0
movl $0x10b, %edx            # imm = 0x10B
leaq 0xa335(%rip), %rcx      # 0xd505
callq 0x2160
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3510
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3540
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3570
testb $0x1, %al
jne 0x321a
jmp 0x337f
leaq -0x38(%rbp), %rdi
callq 0x35b0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x20b0
jmp 0x3231
movq -0x220(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x230(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x200(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x20b0
jmp 0x3260
movq -0x228(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
leaq -0x200(%rbp), %rdx
callq 0x7220
jmp 0x327c
leaq -0x138(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x1e0(%rbp), %rdx
callq 0x71e0
jmp 0x3295
movq -0x230(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x71a0
movb %dl, -0x239(%rbp)
movq %rax, -0x238(%rbp)
jmp 0x32b7
movb -0x239(%rbp), %al
movq -0x238(%rbp), %rcx
movq %rcx, -0x210(%rbp)
movb %al, -0x208(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x72c0
leaq -0x1e0(%rbp), %rdi
callq 0x3010
leaq -0x200(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x38(%rbp), %rdi
callq 0x35d0
jmp 0x3204
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x338a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3368
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x335c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x72c0
leaq -0x1e0(%rbp), %rdi
callq 0x3010
leaq -0x200(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x338a
leaq -0x28(%rbp), %rdi
callq 0x3770
jmp 0x3395
leaq -0x28(%rbp), %rdi
callq 0x3770
jmp 0x339e
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::getMemberNames[abi:cxx11]() const
std::vector<std::string> getMemberNames() const {
            assert(type == JSON_OBJECT);
            std::vector<std::string> names;
            for (auto e : object) {
                names.push_back(e.first);
            }
            return names;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
cmpl $0x6, (%rax)
jne 0x33e6
jmp 0x3405
leaq 0xa009(%rip), %rdi      # 0xd3f6
leaq 0x9fbc(%rip), %rsi      # 0xd3b0
movl $0x98, %edx
leaq 0xa12d(%rip), %rcx      # 0xd52d
callq 0x2160
movq -0x120(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0xb310
movq -0x110(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb330
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7ba0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b70
testb $0x1, %al
jne 0x3451
jmp 0x34cb
leaq -0x28(%rbp), %rdi
callq 0xb360
movq %rax, %rsi
leaq -0xf8(%rbp), %rdi
callq 0x65f0
jmp 0x346b
movq -0x120(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0xb380
jmp 0x3480
leaq -0xf8(%rbp), %rdi
callq 0x67b0
leaq -0x28(%rbp), %rdi
callq 0xb3f0
jmp 0x343e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x34f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x67b0
jmp 0x34f1
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x34e1
movq -0x120(%rbp), %rdi
callq 0x3770
movq -0x118(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x3770
movq -0x100(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::resize(unsigned long)
void resize(size_t size) {
            assert(type == JSON_ARRAY || type == JSON_OBJECT);
            switch (type) {
            case JSON_ARRAY: array.resize(size); break;
            case JSON_OBJECT:
                if (object.size() > size) {
                    size_t delete_size = object.size() - size;
                    for (delete_size; delete_size > 0; delete_size--) {
                        auto mt = object.rbegin();
                        object.erase(mt->first);
                    }
                }
                break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movb $0x1, %al
cmpl $0x5, (%rcx)
movb %al, -0x21(%rbp)
je 0x361f
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3628
jmp 0x362a
jmp 0x3649
leaq 0x9daf(%rip), %rdi      # 0xd3e0
leaq 0x9d78(%rip), %rsi      # 0xd3b0
movl $0xbd, %edx
leaq 0x9f26(%rip), %rcx      # 0xd56a
callq 0x2160
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x5, %eax
je 0x3666
jmp 0x3659
movl -0x34(%rbp), %eax
subl $0x6, %eax
je 0x3679
jmp 0x36ec
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0xbe40
jmp 0x36ec
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x72f0
cmpq -0x10(%rbp), %rax
jbe 0x36ea
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x72f0
subq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x36e8
movq -0x30(%rbp), %rsi
addq $0x68, %rsi
leaq -0x20(%rbp), %rdi
callq 0xbed0
movq -0x30(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbf30
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xbf00
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x36a1
jmp 0x36ea
jmp 0x36ec
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::clear()
void clear() {
            switch (type) {
            case JSON_STRING: str.clear(); break;
            case JSON_ARRAY: array.clear(); break;
            case JSON_OBJECT: object.clear(); break;
            }
            type = JSON_NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x4, %eax
je 0x3734
jmp 0x3720
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x3743
jmp 0x372a
movl -0xc(%rbp), %eax
subl $0x6, %eax
je 0x3752
jmp 0x375f
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2290
jmp 0x375f
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0xc8c0
jmp 0x375f
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0xc8e0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::json_parser::get_parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON::Value*)
static json_parser* get_parser(const std::string& source, Value* v){
            static json_parser singleton_parser;
            singleton_parser.set_json_source(source, v);
            // use singleton create parser
            return &singleton_parser;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x10801(%rip)     # 0x141e8
jne 0x3a2e
leaq 0x107f8(%rip), %rdi     # 0x141e8
callq 0x2310
cmpl $0x0, %eax
je 0x3a2e
leaq 0x107b7(%rip), %rdi     # 0x141b8
callq 0x3b00
jmp 0x3a08
leaq 0x111(%rip), %rdi       # 0x3b20
leaq 0x107a2(%rip), %rsi     # 0x141b8
leaq 0x10783(%rip), %rdx     # 0x141a0
callq 0x21b0
leaq 0x107bf(%rip), %rdi     # 0x141e8
callq 0x2150
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1077b(%rip), %rdi     # 0x141b8
callq 0x3b40
leaq 0x1076f(%rip), %rax     # 0x141b8
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0x10786(%rip), %rdi     # 0x141e8
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x22f0