LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x24(%rdi), %edi
callq 0x3700
movl 0x1d56c(%rbx), %edi
callq 0x3700
movl 0x20(%rbx), %edi
callq 0x3700
movl 0x1c(%rbx), %edi
callq 0x3700
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x6d04
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x6cf1
addq $-0x168, %r15           # imm = 0xFE98
imulq $0xf68, %r12, %r13      # imm = 0xF68
leaq (%r15,%r13), %rdi
callq 0x55ae
addq $-0xf68, %r13           # imm = 0xF098
jne 0x6cdf
imulq $0xf68, %r12, %rsi      # imm = 0xF68
addq $0x8, %rsi
movq %r14, %rdi
callq 0x36f0
movq 0x1d580(%rbx), %rdi
testq %rdi, %rdi
je 0x6d15
callq 0x34e0
movq 0xa0(%rbx), %r14
testq %r14, %r14
je 0x6d29
movq %r14, %rdi
callq 0x79f8
movl $0x80, %esi
movq %r14, %rdi
callq 0x33d0
leaq 0x1d588(%rbx), %rdi
callq 0x3cbc
leaq 0x78(%rbx), %rdi
callq 0x3190
leaq 0x58(%rbx), %rdi
callq 0x3190
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3190
movq %rax, %rdi
callq 0x55a2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x65b4
movq %rax, %r14
movq %rax, 0x30(%rbx)
leaq 0x15f8(%rip), %rsi      # 0x848e
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3bd0
leaq 0x38(%rbx), %rsi
leaq 0x48(%rsp), %rdi
callq 0x3520
leaq 0x58(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3520
leaq 0x78(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3520
movl 0x14(%rbx), %eax
movl 0x98(%rbx), %r10d
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0xcea, %r9d            # imm = 0xCEA
pushq %rax
pushq %r10
callq 0x6624
popq %rax
popq %rcx
leaq 0x8(%rsp), %rdi
callq 0x3190
leaq 0x28(%rsp), %rdi
callq 0x3190
leaq 0x48(%rsp), %rdi
callq 0x3190
leaq 0x68(%rsp), %rdi
callq 0x3190
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x4030
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3190
jmp 0x6f52
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3190
jmp 0x6f61
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3190
jmp 0x6f70
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3630
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::timer(int, sockaddr_in)
void WebServer::timer(int connfd, struct sockaddr_in client_address) {
    users[connfd].init(connfd, client_address, m_root, m_CONNTrigmode, m_close_log, m_user, m_passWord, m_databaseName);

    //初始化client_data数据
    //创建定时器，设置回调函数和超时时间，绑定用户数据，将定时器添加到链表中
    users_timer[connfd].address = client_address;
    users_timer[connfd].sockfd = connfd;
    /*
    util_timer *timer = new util_timer;
    timer->user_data = &users_timer[connfd];
    timer->cb_func = cb_func;
    time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    users_timer[connfd].timer = timer;
    utils.m_timer_lst.add_timer(timer);  */

    tw_timer *timer = new tw_timer(0,0);
    timer->user_data = &users_timer[connfd];
    timer->cb_func = cb_func;
    users_timer[connfd].timer = timer;

    utils.m_time_wheel.add_timer(timer,3 * TIMESLOT);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movslq %esi, %r12
imulq $0xf68, %r12, %r15      # imm = 0xF68
addq 0x28(%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movl 0x1d57c(%rdi), %r13d
movl 0x14(%rdi), %eax
movl %eax, 0xc(%rsp)
leaq 0x38(%rdi), %rsi
leaq 0x48(%rsp), %rdi
callq 0x3520
leaq 0x58(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3520
leaq 0x78(%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x3520
subq $0x8, %rsp
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
movq 0x18(%rsp), %rcx
movl %r13d, %r8d
movl 0x14(%rsp), %r9d
pushq %r14
leaq 0x38(%rsp), %rax
pushq %rax
leaq 0x60(%rsp), %rax
pushq %rax
callq 0x4284
addq $0x20, %rsp
leaq 0x68(%rsp), %rdi
callq 0x3190
leaq 0x28(%rsp), %rdi
callq 0x3190
leaq 0x48(%rsp), %rdi
callq 0x3190
movq 0x1d580(%rbx), %rax
shlq $0x5, %r12
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rax,%r12)
movq 0x1d580(%rbx), %r14
leaq (%r14,%r12), %r15
movl %ebp, 0x10(%r14,%r12)
pushq $0x28
popq %rdi
callq 0x33c0
andq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq %r15, 0x10(%rax)
leaq -0x3327(%rip), %rcx     # 0x4006
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%r14,%r12)
addq $0x1d588, %rbx          # imm = 0x1D588
pushq $0xc
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3cfa
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3190
jmp 0x736f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3190
jmp 0x737e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3630
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::adjust_timer(tw_timer*)
void WebServer::adjust_timer(tw_timer* timer) {
    /* time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    utils.m_timer_lst.adjust_timer(timer); 
    int cur = utils.m_time_wheel.cur_slot;
    int ticks = 3*TIMESLOT / utils.m_time_wheel.SI;
    int N = utils.m_time_wheel.N;
    int ts = (cur + (ticks % N)) % N;
    timer->ratation += ticks/N;
    timer->time_slot = ts; */

    utils.m_time_wheel.adjust_timer(timer,3 * TIMESLOT); 

    LOG_INFO("%s", "adjust timer once");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x1d588, %rdi          # imm = 0x1D588
pushq $0xc
popq %rdx
callq 0x3d88
cmpl $0x0, 0x14(%rbx)
je 0x73ab
popq %rbx
retq
callq 0x53e8
leaq 0xee9(%rip), %rdx       # 0x82a0
leaq 0x1139(%rip), %rcx      # 0x84f7
pushq $0x1
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x5e86
callq 0x53e8
movq %rax, %rdi
popq %rbx
jmp 0x6246
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r15
shlq $0x5, %r15
movq 0x1d580(%rdi), %rdi
addq %r15, %rdi
callq *0x8(%rsi)
leaq 0x1d588(%rbx), %rdi
movq %r14, %rsi
callq 0x3d3e
cmpl $0x0, 0x14(%rbx)
je 0x7414
popq %rbx
popq %r14
popq %r15
retq
callq 0x53e8
movq 0x1d580(%rbx), %rcx
movl 0x10(%rcx,%r15), %ecx
leaq 0x10dd(%rip), %rdx      # 0x8509
pushq $0x1
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x5e86
callq 0x53e8
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6246
nop
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::dealclinetdata()
bool WebServer::dealclinetdata() {
    struct sockaddr_in client_address;
    socklen_t client_addrlength = sizeof(client_address);
    if (0 == m_LISTENTrigmode)
    {
        int connfd = accept(m_listenfd, (struct sockaddr *)&client_address, &client_addrlength);
        if (connfd < 0)
        {
            LOG_ERROR("%s:errno is:%d", "accept error", errno);
            return false;
        }
        if (http_conn::m_user_count >= MAX_FD)
        {
            utils.show_error(connfd, "Internal server busy");
            LOG_ERROR("%s", "Internal server busy");
            return false;
        }
        timer(connfd, client_address);
    }

    else
    {
        while (1)
        {
            int connfd = accept(m_listenfd, (struct sockaddr *)&client_address, &client_addrlength);
            if (connfd < 0)
            {
                LOG_ERROR("%s:errno is:%d", "accept error", errno);
                break;
            }
            if (http_conn::m_user_count >= MAX_FD)
            {
                utils.show_error(connfd, "Internal server busy");
                LOG_ERROR("%s", "Internal server busy");
                break;
            }
            timer(connfd, client_address);
        }
        return false;
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x10, 0x4(%rsp)
cmpl $0x0, 0x1d578(%rdi)
je 0x74b5
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
leaq 0x4ff4(%rip), %r12      # 0xc470
movl 0x1d56c(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x30e0
testl %eax, %eax
js 0x7520
cmpl $0x10000, (%r12)        # imm = 0x10000
jge 0x74e1
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x7228
jmp 0x747c
movl 0x1d56c(%rbx), %edi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x30e0
testl %eax, %eax
js 0x7520
leaq 0x4f9b(%rip), %rcx      # 0xc470
cmpl $0x10000, (%rcx)        # imm = 0x10000
jl 0x7566
leaq 0x1d588(%rbx), %rdi
leaq 0x1042(%rip), %rdx      # 0x8531
movl %eax, %esi
callq 0x3fda
cmpl $0x0, 0x14(%rbx)
jne 0x7526
callq 0x53e8
leaq 0xd98(%rip), %rdx       # 0x82a0
leaq 0x1022(%rip), %rcx      # 0x8531
xorl %ebx, %ebx
pushq $0x3
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x5e86
jmp 0x7557
cmpl $0x0, 0x14(%rbx)
je 0x752a
xorl %ebx, %ebx
jmp 0x757c
callq 0x53e8
movq %rax, %r14
callq 0x3050
movl (%rax), %r8d
leaq 0xfd4(%rip), %rdx       # 0x8515
leaq 0xfdc(%rip), %rcx       # 0x8524
xorl %ebx, %ebx
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x5e86
callq 0x53e8
movq %rax, %rdi
callq 0x6246
jmp 0x757c
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x7228
movb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %rbx
movq %rsi, %r14
movl 0x1c(%rdi), %edi
movq %rsp, %rsi
xorl %r15d, %r15d
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3100
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x75e4
testl %eax, %eax
cmovlel %r15d, %eax
cmpq %r15, %rax
je 0x75e1
movzbl (%rsp,%r15), %ecx
movq %r14, %rdx
cmpl $0xe, %ecx
je 0x75d9
cmpl $0xf, %ecx
jne 0x75dc
movq %rbx, %rdx
movb $0x1, (%rdx)
incq %r15
jmp 0x75bf
movb $0x1, %r15b
movl %r15d, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::dealwithread(int)
void WebServer::dealwithread(int sockfd)
{
    tw_timer *timer = users_timer[sockfd].timer;

    //reactor
    if (1 == m_actormodel)
    {
        if (timer)
        {
            adjust_timer(timer);
        }

        //若监测到读事件，将该事件放入请求队列
        m_pool->append(users + sockfd, 0);

        while (true)
        {
            if (1 == users[sockfd].improv)
            {
                if (1 == users[sockfd].timer_flag)
                {
                    deal_timer(timer, sockfd);
                    users[sockfd].timer_flag = 0;
                }
                users[sockfd].improv = 0;
                break;
            }
        }
    }
    else
    {
        //proactor
        if (users[sockfd].read_once())
        {
            LOG_INFO("deal with the client(%s)", inet_ntoa(users[sockfd].get_address()->sin_addr));

            //若监测到读事件，将该事件放入请求队列
            m_pool->append_p(users + sockfd);

            if (timer)
            {
                adjust_timer(timer);
            }
        }
        else
        {
            deal_timer(timer, sockfd);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1d580(%rdi), %rax
movslq %esi, %r15
movq %r15, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %r14
cmpl $0x1, 0x18(%rdi)
jne 0x7679
testq %r14, %r14
je 0x762d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7390
movq 0xa0(%rbx), %rdi
imulq $0xf68, %r15, %r15      # imm = 0xF68
movq 0x28(%rbx), %rsi
addq %r15, %rsi
xorl %edx, %edx
callq 0x7ba8
movq 0x28(%rbx), %rax
cmpl $0x1, (%rax,%r15)
jne 0x766a
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x73da
movq 0x28(%rbx), %rax
andl $0x0, (%rax,%r15)
andl $0x0, 0x4(%rax,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
imulq $0xf68, %r15, %r15      # imm = 0xF68
movq 0x28(%rbx), %rdi
addq %r15, %rdi
callq 0x443a
testb %al, %al
je 0x76fb
cmpl $0x0, 0x14(%rbx)
jne 0x76d0
callq 0x53e8
movq %rax, %r12
movq 0x28(%rbx), %rax
movl 0x1c(%rax,%r15), %edi
callq 0x3180
leaq 0xe93(%rip), %rdx       # 0x8546
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x5e86
callq 0x53e8
movq %rax, %rdi
callq 0x6246
movq 0xa0(%rbx), %rdi
addq 0x28(%rbx), %r15
movq %r15, %rsi
callq 0x7c1c
testq %r14, %r14
je 0x7670
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7390
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x73da
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::dealwithwrite(int)
void WebServer::dealwithwrite(int sockfd)
{
    tw_timer *timer = users_timer[sockfd].timer;
    //reactor
    if (1 == m_actormodel)
    {
        if (timer)
        {
            adjust_timer(timer);
        }

        m_pool->append(users + sockfd, 1);

        while (true)
        {
            if (1 == users[sockfd].improv)
            {
                if (1 == users[sockfd].timer_flag)
                {
                    deal_timer(timer, sockfd);
                    users[sockfd].timer_flag = 0;
                }
                users[sockfd].improv = 0;
                break;
            }
        }
    }
    else
    {
        //proactor
        if (users[sockfd].write())
        {
            LOG_INFO("send data to the client(%s)", inet_ntoa(users[sockfd].get_address()->sin_addr));

            if (timer)
            {
                adjust_timer(timer);
            }
        }
        else
        {
            deal_timer(timer, sockfd);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1d580(%rdi), %rax
movslq %esi, %r15
movq %r15, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %r14
cmpl $0x1, 0x18(%rdi)
jne 0x7796
testq %r14, %r14
je 0x7749
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7390
movq 0xa0(%rbx), %rdi
imulq $0xf68, %r15, %r15      # imm = 0xF68
movq 0x28(%rbx), %rsi
addq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x7ba8
movq 0x28(%rbx), %rax
cmpl $0x1, (%rax,%r15)
jne 0x7787
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x73da
movq 0x28(%rbx), %rax
andl $0x0, (%rax,%r15)
andl $0x0, 0x4(%rax,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
imulq $0xf68, %r15, %r12      # imm = 0xF68
movq 0x28(%rbx), %rdi
addq %r12, %rdi
callq 0x4eb0
testb %al, %al
je 0x7805
cmpl $0x0, 0x14(%rbx)
jne 0x77ed
callq 0x53e8
movq %rax, %r15
movq 0x28(%rbx), %rax
movl 0x1c(%rax,%r12), %edi
callq 0x3180
leaq 0xd8f(%rip), %rdx       # 0x855f
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x5e86
callq 0x53e8
movq %rax, %rdi
callq 0x6246
testq %r14, %r14
je 0x778d
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7390
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x73da
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/././threadpool/threadpool.h
// Function: threadpool<http_conn>::threadpool(int, connection_pool*, int, int)
threadpool<T>::threadpool( int actor_model, connection_pool *connPool, int thread_number, int max_requests) : m_actor_model(actor_model),m_thread_number(thread_number), m_max_requests(max_requests), m_threads(NULL),m_connPool(connPool)
{
    if (thread_number <= 0 || max_requests <= 0)
        throw std::exception();
    m_threads = new pthread_t[m_thread_number];
    if (!m_threads)
        throw std::exception();
    for (int i = 0; i < thread_number; ++i)
    {
        if (pthread_create(m_threads + i, NULL, worker, this) != 0)
        {
            delete[] m_threads;
            throw std::exception();
        }
        if (pthread_detach(m_threads[i]))
        {
            delete[] m_threads;
            throw std::exception();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r12
movl %ecx, (%rdi)
movl %r8d, 0x4(%rdi)
andq $0x0, 0x8(%rdi)
movl %esi, %r15d
leaq 0x10(%rdi), %rbx
movq %rbx, 0x18(%rdi)
movq %rbx, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, 0x10(%rsp)
callq 0x53a2
leaq 0x50(%r12), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6974
movq %r14, 0x70(%r12)
movl %r15d, 0x78(%r12)
testl %ebp, %ebp
jle 0x7b49
testl %r13d, %r13d
jle 0x7b49
movslq (%r12), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x8(%r12)
movl %ebp, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
leaq 0x1df(%rip), %r13       # 0x7caa
cmpq %r15, %r14
je 0x7b3a
movq 0x8(%r12), %rdi
addq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x3690
movq 0x8(%r12), %rdi
testl %eax, %eax
jne 0x7b04
movq (%rdi,%r15), %rdi
callq 0x32f0
addq $0x8, %r15
testl %eax, %eax
je 0x7acb
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x7b0e
callq 0x34e0
pushq $0x8
popq %rdi
callq 0x31c0
movq 0x44ab(%rip), %rcx      # 0xbfc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x44ad(%rip), %rsi      # 0xbfd8
movq 0x44be(%rip), %rdx      # 0xbff0
movq %rax, %rdi
callq 0x3610
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31c0
movq 0x4470(%rip), %rcx      # 0xbfc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4472(%rip), %rsi      # 0xbfd8
movq 0x4483(%rip), %rdx      # 0xbff0
movq %rax, %rdi
callq 0x3610
movq %rax, %r12
jmp 0x7b8e
movq %rax, %r12
jmp 0x7b98
jmp 0x7b81
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0x36c0
movq 0x10(%rsp), %rdi
callq 0x3450
movq %rbx, %rdi
callq 0x7c80
movq %r12, %rdi
callq 0x3630
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x54be
movq 0x20(%rbx), %r12
movslq 0x4(%rbx), %r13
cmpq %r13, %r12
jae 0x7bfe
leaq 0x10(%rbx), %rdi
movl %ebp, 0x10(%r15)
movq %rsp, %rsi
callq 0x7dce
movq %r14, %rdi
callq 0x5522
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x6a0e
jmp 0x7c06
movq %r14, %rdi
callq 0x5522
cmpq %r13, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x54be
movq 0x20(%rbx), %r15
movslq 0x4(%rbx), %r12
cmpq %r12, %r15
jae 0x7c66
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x7dce
movq %r14, %rdi
callq 0x5522
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x6a0e
jmp 0x7c6e
movq %r14, %rdi
callq 0x5522
cmpq %r12, %r15
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JianjiaoSQ[P]MyPoorWebServer/././threadpool/threadpool.h
// Function: threadpool<http_conn>::run()
void threadpool<T>::run()
{
    while (true)
    {
        m_queuestat.wait();
        m_queuelocker.lock();
        if (m_workqueue.empty())
        {
            m_queuelocker.unlock();
            continue;
        }
        T *request = m_workqueue.front();
        m_workqueue.pop_front();
        m_queuelocker.unlock();
        if (!request)
            continue;
        if (1 == m_actor_model)
        {
            if (0 == request->m_state)
            {
                if (request->read_once())
                {
                    request->improv = 1;
                    connectionRAII mysqlcon(&request->mysql, m_connPool);
                    request->process();
                }
                else
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
            else
            {
                if (request->write())
                {
                    request->improv = 1;
                }
                else
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
        }
        else
        {
            connectionRAII mysqlcon(&request->mysql, m_connPool);
            request->process();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
leaq 0x28(%rdi), %r15
leaq 0x10(%rdi), %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
callq 0x69f8
movq %r15, %rdi
callq 0x54be
movq (%r12), %rax
cmpq %r12, %rax
je 0x7d2d
movq 0x10(%rax), %rbp
movq %r12, %rdi
callq 0x7daa
movq %r15, %rdi
callq 0x5522
testq %rbp, %rbp
je 0x7cda
cmpl $0x1, 0x78(%rbx)
jne 0x7d37
cmpl $0x0, 0x10(%rbp)
je 0x7d59
movq %rbp, %rdi
callq 0x4eb0
movl $0x1, 0x4(%rbp)
testb %al, %al
jne 0x7cda
jmp 0x7d86
movq %r15, %rdi
callq 0x5522
jmp 0x7cda
leaq 0x8(%rbp), %rsi
movq 0x70(%rbx), %rdx
movq %r13, %rdi
callq 0x6936
movq %rbp, %rdi
callq 0x5356
movq %r13, %rdi
callq 0x695c
jmp 0x7cda
movq %rbp, %rdi
callq 0x443a
movl $0x1, 0x4(%rbp)
testb %al, %al
je 0x7d86
leaq 0x8(%rbp), %rsi
movq 0x70(%rbx), %rdx
movq %r13, %rdi
callq 0x6936
movq %rbp, %rdi
callq 0x5356
jmp 0x7d4f
movl $0x1, (%rbp)
jmp 0x7cda
jmp 0x7d94
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x695c
movq %rbx, %rdi
callq 0x3630
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
leaq 0x24(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x1c(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x14(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x4(%rdi), %rax
movq %rax, (%rsp)
leaq 0x72f(%rip), %r15       # 0x8640
leaq 0x6d8(%rip), %r13       # 0x85f0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30a0
leal -0x61(%rax), %ecx
cmpl $0x13, %ecx
ja 0x7f7c
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
movq %r12, %r14
jmpq *%rax
movq 0x30(%rsp), %r14
jmp 0x7f68
movq 0x8(%rsp), %r14
jmp 0x7f68
movq 0x28(%rsp), %r14
jmp 0x7f68
movq (%rsp), %r14
jmp 0x7f68
movq 0x20(%rsp), %r14
jmp 0x7f68
movq 0x10(%rsp), %r14
jmp 0x7f68
movq 0x18(%rsp), %r14
movq 0x4049(%rip), %rax      # 0xbfb8
movq (%rax), %rdi
callq 0x3590
movl %eax, (%r14)
jmp 0x7f18
cmpl $-0x1, %eax
jne 0x7f18
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x4c13(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x98(%rdx), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *(%rax)
jmp 0x2449
addq $0x30, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2220
jmp 0x2449
leaq 0x4c97(%rip), %rsi      # 0x70ba
leaq -0x9(%rbp), %rdx
jmp 0x2441
leaq 0x4c80(%rip), %rsi      # 0x70b0
leaq -0xb(%rbp), %rdx
jmp 0x2441
leaq 0x4c78(%rip), %rsi      # 0x70b5
leaq -0xa(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x56ea
leaq 0x70(%r14), %rcx
cmpq %rcx, %rax
je 0x2a1d
movq %r15, %rdi
movq %rax, %rsi
callq 0x5774
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a08
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x6, (%rdi)
je 0x2a86
movq %r14, %rdi
callq 0x2dca
movl $0x6, (%r14)
addq $0x68, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x57d6
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, -0x30(%rbp)
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x2b3a
cmpl $0x5, %eax
jne 0x2bf0
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3790
cmpl $0x6, (%rsi)
jne 0x2c02
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %rsi, -0x38(%rbp)
callq 0x2c76
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, -0x40(%rbp)
addq $0x68, -0x30(%rbp)
leaq -0x98(%rbp), %r12
leaq -0x78(%rbp), %r13
leaq -0x140(%rbp), %rbx
leaq -0x208(%rbp), %r14
cmpq -0x40(%rbp), %r15
je 0x2be7
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movq %r13, %rdi
movq %r12, %rsi
callq 0x2220
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0x4244
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x44e4
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x42a8
movq %r14, %rdi
callq 0x4288
movq %rbx, %rdi
callq 0x2a36
movq %r13, %rdi
callq 0x20c0
movq %r12, %rdi
callq 0x20c0
addq $0x20, %r15
jmp 0x2b7c
leaq -0x58(%rbp), %rdi
callq 0x2e10
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47cc(%rip), %rdi      # 0x73d5
leaq 0x4690(%rip), %rsi      # 0x72a0
leaq 0x47de(%rip), %rcx      # 0x73f5
movl $0x10b, %edx            # imm = 0x10B
callq 0x2130
movq %rax, %rbx
jmp 0x2c54
movq %rax, %rbx
jmp 0x2c4b
movq %rax, %rbx
jmp 0x2c3f
movq %rax, %rbx
leaq -0x208(%rbp), %rdi
callq 0x4288
leaq -0x140(%rbp), %rdi
callq 0x2a36
leaq -0x78(%rbp), %rdi
callq 0x20c0
leaq -0x98(%rbp), %rdi
callq 0x20c0
jmp 0x2c65
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2e10
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
cmpl $0x6, (%rsi)
jne 0x2cf5
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x80(%rsi), %r12
addq $0x70, %r14
leaq -0xe8(%rbp), %r15
cmpq %r14, %r12
je 0x2ce2
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x3e22
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5aba
movq %r15, %rdi
callq 0x3e7c
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
jmp 0x2cb0
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45ea(%rip), %rdi      # 0x72e6
leaq 0x459d(%rip), %rsi      # 0x72a0
leaq 0x4713(%rip), %rcx      # 0x741d
movl $0x98, %edx
callq 0x2130
movq %rax, %r14
jmp 0x2d28
movq %rax, %r14
leaq -0xe8(%rbp), %rdi
callq 0x3e7c
movq %rbx, %rdi
callq 0x2e10
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
leal -0x5(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2daa
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x5, %eax
jne 0x2d70
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d04
subq 0x90(%r14), %rbx
jae 0x2d9f
leaq 0x68(%r14), %r15
addq $0x70, %r14
testq %rbx, %rbx
je 0x2d9f
movq %r14, %rdi
callq 0x21d0
leaq 0x20(%rax), %rsi
movq %r15, %rdi
callq 0x5ed0
incq %rbx
jmp 0x2d81
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x451f(%rip), %rdi      # 0x72d0
leaq 0x44e8(%rip), %rsi      # 0x72a0
leaq 0x469b(%rip), %rcx      # 0x745a
movl $0xbd, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x2dfd
cmpl $0x5, %eax
je 0x2df2
cmpl $0x4, %eax
jne 0x2e06
andq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
jmp 0x2e06
leaq 0x50(%rbx), %rdi
callq 0x6086
jmp 0x2e06
leaq 0x68(%rbx), %rdi
callq 0x604e
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x8340(%rip), %al       # 0xb1a0
testb %al, %al
je 0x2e87
leaq 0x8305(%rip), %r15      # 0xb170
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f38
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8312(%rip), %rdi      # 0xb1a0
callq 0x2270
testl %eax, %eax
je 0x2e64
leaq 0x82e2(%rip), %rax      # 0xb180
movq %rax, 0x82cb(%rip)      # 0xb170
leaq 0x82c4(%rip), %rsi      # 0xb170
andq $0x0, 0x82c4(%rip)      # 0xb178
movb $0x0, 0x82c5(%rip)      # 0xb180
andq $0x0, 0x82cd(%rip)      # 0xb190
leaq 0x64(%rip), %rdi        # 0x2f2e
leaq 0x8287(%rip), %rdx      # 0xb158
callq 0x2180
leaq 0x82c3(%rip), %rdi      # 0xb1a0
callq 0x2120
jmp 0x2e64
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse()
int parse()
        {
            skip_blank();
            int ret = 0;
            if ((ret = parse_value()) == PARSE_OK) {
                skip_blank();
                if (it != json_source.end()) {
                    root->clear();
                    return PARSE_ROOT_NOT_SINGULAR;
                }
            }
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f5a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2f7e
testl %eax, %eax
jne 0x2f26
movq %rbx, %rdi
callq 0x2f5a
movq (%rbx), %rcx
addq 0x8(%rbx), %rcx
movl $0x0, %eax
cmpq %rcx, 0x20(%rbx)
je 0x2f26
movq 0x28(%rbx), %rdi
callq 0x2dca
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_value(JSON::Value*)
int parse_value(Value* element = nullptr) {
            if (it == json_source.end())
                return PARSE_EXPECT_VALUE;
            switch (*it) {
            case 'n': return parse_literal("null", JSON_NULL, element);
            case 't': return parse_literal("true", JSON_TRUE, element);
            case 'f': return parse_literal("false", JSON_FALSE, element);
            case '[': return parse_array(element);
            case '{': return parse_object(element);
            case '\"': return parse_string(element);
            case '\0': return PARSE_EXPECT_VALUE;
            default:
                if (*it == '-' || (*it >= '0' && *it <= '9')) {
                    return parse_number(element);
                }
                return PARSE_INVALID_VALUE;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq (%rdi), %rsi
movq 0x20(%rdi), %rdx
addq 0x8(%rdi), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x3024
movzbl (%rdx), %edx
testl %edx, %edx
je 0x3024
cmpl $0x22, %edx
je 0x2ffc
cmpl $0x2d, %edx
je 0x300d
cmpl $0x5b, %edx
je 0x3016
cmpl $0x66, %edx
je 0x2fd3
cmpl $0x7b, %edx
je 0x2ff3
cmpl $0x74, %edx
je 0x2fe1
cmpl $0x6e, %edx
jne 0x3005
leaq 0x40e1(%rip), %rsi      # 0x70b0
xorl %edx, %edx
jmp 0x2fed
leaq 0x40e0(%rip), %rsi      # 0x70ba
movl $0x2, %edx
jmp 0x2fed
leaq 0x40cd(%rip), %rsi      # 0x70b5
movl $0x1, %edx
popq %rbp
jmp 0x3026
movq %rcx, %rsi
popq %rbp
jmp 0x32d4
movq %rcx, %rsi
popq %rbp
jmp 0x35b8
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x301f
movq %rcx, %rsi
popq %rbp
jmp 0x363e
movq %rcx, %rsi
popq %rbp
jmp 0x310a
movl $0x2, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_literal(char const*, JSON::json_type, JSON::Value*)
int parse_literal(const char* dst, json_type type, Value* element = nullptr) {
            int len = strlen(dst);
            if (strncmp(&(*it), dst, len) == 0) {
                it += len;
                if (element != nullptr) {
                    switch (type) {
                    case JSON_NULL: element->clear(); break;
                    case JSON_TRUE: *element = true; break;
                    case JSON_FALSE: *element = false; break;
                    }
                }
                else {
                    switch (type) {
                    case JSON_NULL: root->clear(); break;
                    case JSON_TRUE: *root = true; break;
                    case JSON_FALSE: *root = false; break;
                    }
                }
                return PARSE_OK;
            }
            else
                return PARSE_INVALID_VALUE;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x20b0
movq 0x20(%r12), %rbx
movslq %eax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x20d0
testl %eax, %eax
je 0x3076
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0x2c(%rbp), %eax
addq %r13, %rbx
movq %rbx, 0x20(%r12)
xorl %ebx, %ebx
testq %r15, %r15
je 0x309b
cmpl $0x2, %eax
je 0x30c6
cmpl $0x1, %eax
je 0x30b5
testl %eax, %eax
jne 0x3065
movq %r15, %rdi
jmp 0x30ae
cmpl $0x2, %eax
je 0x30f0
cmpl $0x1, %eax
je 0x30d7
testl %eax, %eax
jne 0x3065
movq 0x28(%r12), %rdi
callq 0x2dca
jmp 0x3065
movq %r15, %rdi
callq 0x2dca
movl $0x1, (%r15)
jmp 0x3065
movq %r15, %rdi
callq 0x2dca
movl $0x2, (%r15)
jmp 0x3065
movq 0x28(%r12), %r14
movq %r14, %rdi
callq 0x2dca
movl $0x1, (%r14)
jmp 0x3065
movq 0x28(%r12), %r14
movq %r14, %rdi
callq 0x2dca
movl $0x2, (%r14)
jmp 0x3065
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_string(JSON::Value*)
int parse_string(Value* element = nullptr) {
            std::string tmp_str;
            std::string::const_iterator tmp_it = it;
            int ret = parse_string(tmp_str, tmp_it);
            if (ret == PARSE_OK) {
                it = tmp_it;
                if (element != nullptr)
                    *element = tmp_str;
                else
                    *root = tmp_str;
            }
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x20(%rdi), %rax
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x40(%rbp), %rsi
callq 0x4882
movl %eax, %r14d
testl %eax, %eax
jne 0x3613
movq -0x20(%rbp), %rax
movq %rax, 0x20(%r15)
testq %rbx, %rbx
jne 0x3607
movq 0x28(%r15), %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ea2
leaq -0x40(%rbp), %rdi
callq 0x20c0
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_number(JSON::Value*)
int parse_number(Value* element = nullptr) {
            std::string::const_iterator tmp_it = it;
            if (*tmp_it == '-')
                tmp_it++;
            if (*tmp_it == '0')
                tmp_it++;
            else {
                if (!ISDIGIT1TO9(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            if (*tmp_it == '.') {
                tmp_it++;
                if (!ISDIGIT(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            if (*tmp_it == 'e' || *tmp_it == 'E') {
                tmp_it++;
                if (*tmp_it == '-' || *tmp_it == '+')
                    tmp_it++;
                if (!ISDIGIT(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            // if (*tmp_it != ' ' && *tmp_it != '\0')
            //    return PARSE_INVALID_VALUE;
            double dst_number = strtod(&(*it), NULL);
            if (errno == ERANGE && (dst_number == HUGE_VAL || dst_number == -HUGE_VAL))
                return PARSE_NUMBER_OVERFLOW;
            it = tmp_it;
            if (element != nullptr)
                *element = dst_number;
            else
                *root = dst_number;
            return PARSE_OK;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movb (%rdi), %cl
movq %rdi, %r15
cmpb $0x2d, %cl
jne 0x3667
incq %r15
movb 0x1(%rdi), %cl
pushq $0x2
popq %rax
cmpb $0x30, %cl
jne 0x36a1
movb 0x1(%r15), %cl
incq %r15
cmpb $0x2e, %cl
jne 0x36c3
movb 0x1(%r15), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3756
addq $0x2, %r15
movb (%r15), %cl
cmpb $0x30, %cl
jl 0x3700
cmpb $0x39, %cl
ja 0x36c3
incq %r15
jmp 0x368f
addb $-0x31, %cl
cmpb $0x8, %cl
ja 0x3756
incq %r15
movb (%r15), %cl
cmpb $0x30, %cl
jl 0x3676
incq %r15
cmpb $0x3a, %cl
jb 0x36b0
decq %r15
movzbl %cl, %ecx
orl $0x20, %ecx
cmpl $0x65, %ecx
jne 0x3700
movzbl 0x1(%r15), %ecx
cmpl $0x2d, %ecx
je 0x36dd
cmpl $0x2b, %ecx
jne 0x36e5
movb 0x2(%r15), %cl
pushq $0x2
jmp 0x36e7
pushq $0x1
popq %rdx
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3756
addq %rdx, %r15
movb 0x1(%r15), %al
incq %r15
addb $-0x30, %al
cmpb $0xa, %al
jb 0x36f3
xorl %esi, %esi
callq 0x2150
movq %xmm0, -0x28(%rbp)
movq %xmm0, %r12
callq 0x2040
cmpl $0x22, (%rax)
sete %al
btrq $0x3f, %r12
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %r12
sete %cl
testb %cl, %al
je 0x373a
pushq $0x4
popq %rax
jmp 0x3756
movq %r15, 0x20(%r14)
testq %rbx, %rbx
jne 0x3747
movq 0x28(%r14), %rbx
movq %rbx, %rdi
movq -0x28(%rbp), %xmm0
callq 0x4156
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::operator=(JSON::Value const&)
void operator=(const Value& other) {
            switch (other.get_type()) {
            case JSON_NULL: clear(); break;
            case JSON_TRUE: operator=(true); break;
            case JSON_FALSE: operator=(false); break;
            case JSON_NUMBER: operator=(other.asDouble()); break;
            case JSON_ARRAY:
                clear();
                for (size_t i = 0; i < other.size(); i++)
                    array.push_back(other[i]);
                break;
            case JSON_OBJECT:
                std::vector<std::string> names = other.getMemberNames();
                for (auto it : names)
                    object.insert(make_pair(it, other[it]));
                break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movl (%rsi), %eax
cmpq $0x6, %rax
ja 0x40ef
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30ab(%rip), %rcx      # 0x7040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r12, %rdi
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2dca
movq %r12, %rdi
callq 0x2dca
movl $0x2, (%r12)
jmp 0x40ef
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c76
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
addq $0x68, %r12
movq %r12, -0x30(%rbp)
leaq -0x90(%rbp), %r12
cmpq -0x38(%rbp), %r15
je 0x40e6
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2220
leaq -0x138(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4244
leaq -0x200(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x44e4
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x42a8
movq %rbx, %rdi
callq 0x4288
leaq -0x138(%rbp), %rdi
callq 0x2a36
leaq -0x70(%rbp), %rdi
callq 0x20c0
movq %r12, %rdi
callq 0x20c0
addq $0x20, %r15
jmp 0x3ff5
movq %r12, %rdi
callq 0x2dca
movl $0x1, (%r12)
jmp 0x40ef
movq %r14, %rdi
callq 0x4180
movq %r12, %rdi
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4156
movq %r12, %rdi
callq 0x2dca
addq $0x50, %r12
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x41ac
cmpq %rax, %rbx
jae 0x40ef
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41f6
movq %r12, %rdi
movq %rax, %rsi
callq 0x3790
incq %rbx
jmp 0x40be
leaq -0x50(%rbp), %rdi
callq 0x2e10
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4134
movq %rax, %rbx
jmp 0x412b
movq %rax, %rbx
jmp 0x411f
movq %rax, %rbx
leaq -0x200(%rbp), %rdi
callq 0x4288
leaq -0x138(%rbp), %rdi
callq 0x2a36
leaq -0x70(%rbp), %rdi
callq 0x20c0
leaq -0x90(%rbp), %rdi
callq 0x20c0
jmp 0x4145
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2e10
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::size() const
size_t size() const {
            assert(type == JSON_ARRAY || type == JSON_OBJECT);
            switch (type) {
            case JSON_ARRAY: return array.size();
            case JSON_OBJECT: return object.size();
            }
        }

// Assembly:
movl (%rdi), %eax
addl $-0x5, %eax
cmpl $0x2, %eax
jae 0x41d5
testl %eax, %eax
je 0x41c2
movq 0x90(%rdi), %rax
retq
movq 0x58(%rdi), %rax
subq 0x50(%rdi), %rax
movl $0xa8, %ecx
cqto
idivq %rcx
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x30f0(%rip), %rdi      # 0x72d0
leaq 0x30b9(%rip), %rsi      # 0x72a0
leaq 0x310c(%rip), %rcx      # 0x72fa
pushq $0x6c
popq %rdx
callq 0x2130