LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::SaveStackBuffer()
void LibCoroCoroutine::SaveStackBuffer()
    {
        if (NULL != stack && stack->shared && NULL != stack_sp)
        {
            if (NULL != save_buffer)
            {
                free(save_buffer);
            }
            save_buffer = malloc(save_buffer_size);
            memcpy(save_buffer, stack_sp, save_buffer_size);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2995
cmpb $0x1, 0x18(%rax)
jne 0x2995
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x2995
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x296f
callq 0x2210
movq 0x58(%rbx), %r14
movq %r14, %rdi
callq 0x2250
movq %rax, 0x50(%rbx)
movq 0x60(%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::ResumeStackBuffer()
void LibCoroCoroutine::ResumeStackBuffer()
    {
        if (NULL != save_buffer && NULL != stack && stack->shared)
        {
            memcpy(stack_sp, save_buffer, save_buffer_size);
            free(save_buffer);
            save_buffer = NULL;
            stack_sp = NULL;
            save_buffer_size = 0;

        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0x29e6
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x29e6
cmpb $0x1, 0x18(%rax)
jne 0x29e6
leaq 0x50(%rbx), %r14
movq 0x58(%rbx), %rdx
movq 0x60(%rbx), %rdi
callq 0x21a0
movq 0x50(%rbx), %rdi
callq 0x2210
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::~LibCoroCoroutine()
LibCoroCoroutine::~LibCoroCoroutine()
    {
        if (NULL != stack)
        {
            if (stack->shared)
            {
                if (stack->coro == this)
                {
                    stack->coro = NULL;
                }
            }
            else
            {
                delete stack;
            }
        }
        if (NULL != save_buffer)
        {
            free(save_buffer);
        }
        coro_destroy(&ctx);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2a52
cmpb $0x1, 0x18(%r14)
jne 0x2a3d
cmpq %rbx, 0x10(%r14)
jne 0x2a52
movq $0x0, 0x10(%r14)
jmp 0x2a52
movq %r14, %rdi
callq 0x605c
movl $0x20, %esi
movq %r14, %rdi
callq 0x21e0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2a60
callq 0x2210
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2a7a
addq $0x18, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2a84
movq %rax, %rdi
callq 0x2858
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::Yield(bool)
void LibCoroCoroutine::Yield(bool release_current)
    {
        CoroutineStack& coro_stack = getCoroEnv().coro_stack;
        LibCoroCoroutine* next = getCoroEnv().main;
        if (!coro_stack.empty())
        {
            next = coro_stack.top();
            coro_stack.pop();
        }
        next->Resume(release_current);

    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x8732(%rip), %r15      # 0xb1d8
movq %r15, %rdi
callq 0x2f46
movq %rax, %r14
movq %r15, %rdi
callq 0x2f46
movq 0x40(%r14), %rcx
cmpq 0x20(%r14), %rcx
je 0x2ae8
movq %r14, %rdi
addq $0x10, %rdi
cmpq 0x48(%r14), %rcx
jne 0x2add
movq 0x58(%r14), %rax
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rax), %rcx
movq -0x8(%rcx), %r14
callq 0x3332
jmp 0x2aec
movq 0x8(%rax), %r14
movzbl %bl, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2afc
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::swapCoroFunc(void*)
static void swapCoroFunc(void* data)
    {
        while (1)
        {
            CoroEnv& coro_env = getCoroEnv();
            SwapContext& swap = coro_env.swap_ctx;
            swap.from->SaveStackBuffer();
            swap.to->ResumeStackBuffer();

            //printf("####%d resumex %d\n", swap.to->id,coro_env.current->id);
            coro_env.current = swap.to;
            coro_transfer(&(swap.swap_coro), &(swap.to->ctx));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8477(%rip), %rbx      # 0xb1d8
movq %rbx, %rdi
callq 0x2f46
movq %rax, %r14
movq 0x80(%rax), %rdi
callq 0x2944
movq 0x88(%r14), %rdi
callq 0x299e
movq 0x88(%r14), %rsi
movq %rsi, (%r14)
addq $0x90, %r14
movq %r14, %rdi
callq 0x5e5c
jmp 0x2d61
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/./thread_mutex.h
// Function: coroxx::ThreadMutex::ThreadMutex(int)
ThreadMutex(int type = PTHREAD_MUTEX_DEFAULT)
			{
				pthread_mutexattr_t attr;
				pthread_mutexattr_init(&attr);
				pthread_mutexattr_settype(&attr, type);
				pthread_mutex_init(&m_mutex, &attr);
				pthread_mutexattr_destroy(&attr);
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7f33(%rip), %rax      # 0xace8
movq %rax, (%rdi)
leaq 0xc(%rsp), %r15
movq %r15, %rdi
callq 0x2060
movq %r15, %rdi
movl %ebx, %esi
callq 0x2280
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x22a0
movq %r15, %rdi
callq 0x2290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::CoroEnv::GetCoroStack()
CoroStack* GetCoroStack()
            {
                if (share_stack_pool.size() < share_stack_count)
                {
                    CoroStack* s = new CoroStack(stack_size, true);
                    share_stack_pool.pool.push_back(s);
                    return s;
                }
                if (share_stack_pool.pool.empty())
                {
                    return new CoroStack(stack_size, false);
                }
                size_t idx = share_stack_pool.cursor;
                if (idx >= share_stack_pool.size())
                {
                    idx = 0;
                    share_stack_pool.cursor = 0;
                }
                share_stack_pool.cursor++;
                return share_stack_pool.pool[idx];
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movl 0xb4(%rdi), %esi
cmpq %rsi, %rcx
jae 0x2e67
movl $0x20, %edi
callq 0x21d0
movq %rax, %r14
movl 0xb0(%rbx), %esi
movq $0x0, 0x10(%rax)
movb $0x1, 0x18(%rax)
movq %rax, %rdi
callq 0x5f28
movq %r14, (%rsp)
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x2eb2
movq %r14, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0x2ec1
cmpq %rdx, %rax
je 0x2e89
movq 0x78(%rbx), %rdx
cmpq %rcx, %rdx
jb 0x2e7f
movq $0x0, 0x78(%rbx)
xorl %edx, %edx
incq 0x78(%rbx)
movq (%rax,%rdx,8), %r14
jmp 0x2ec5
movl $0x20, %edi
callq 0x21d0
movq %rax, %r14
movl 0xb0(%rbx), %esi
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
movq %rax, %rdi
callq 0x5f28
jmp 0x2ec5
addq $0x60, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x31c0
movq (%rsp), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2ed2
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::SwapContext::Init()
void Init()
            {
                if (inited)
                {
                    return;
                }
                coro_stack_alloc(&swap_stack, 0);
                coro_create(&swap_coro, swapCoroFunc, NULL, swap_stack.sptr, swap_stack.ssze);
                inited = true;
            }

// Assembly:
cmpb $0x0, 0x28(%rdi)
jne 0x2f1e
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
xorl %esi, %esi
callq 0x5f28
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %r8
leaq -0x1bc(%rip), %rsi      # 0x2d56
xorl %edx, %edx
callq 0x5e79
movb $0x1, 0x28(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/./thread_local.h
// Function: coroxx::ThreadLocal<coroxx::CoroEnv>::GetValue()
T& GetValue()
			{
				T* local_thread_value = static_cast<T*>(pthread_getspecific(
				        m_key));
				if (NULL == local_thread_value)
				{
					T* newObj = InitialValue();
					pthread_setspecific(m_key, newObj);
					local_thread_value = newObj;
				}
				return *local_thread_value;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x22c0
movq %rax, %r14
testq %rax, %rax
jne 0x2f71
movq %rbx, %rdi
callq 0x2f7c
movq %rax, %r14
movl (%rbx), %edi
movq %rax, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::RunFunc(void*)
void* Scheduler::RunFunc(void* data)
    {
        Scheduler* s = (Scheduler*) data;
        s->Run();
        delete s;
        return NULL;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3630
leaq 0x178(%rbx), %rdi
callq 0x3170
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x35c4
movq 0x170(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
leaq 0x774d(%rip), %rax      # 0xad18
movq %rax, 0x128(%rbx)
leaq 0x130(%rbx), %rdi
callq 0x2360
leaq 0x7703(%rip), %rax      # 0xace8
movq %rax, 0xf8(%rbx)
leaq 0x100(%rbx), %rdi
callq 0x2200
leaq 0xc8(%rbx), %rdi
callq 0x4da8
leaq 0x78(%rbx), %rdi
callq 0x4e00
leaq 0x38(%rbx), %rdi
callq 0x4e50
movq %rbx, %rdi
callq 0x4e50
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x21e0
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Run()
void Scheduler::Run()
    {
        g_current_scheduler.SetValue(this);
        InitCoroPool();
        sched_coro = new CoroType(options);
        sched_coro->ResetContext(Scheduler::RoutineFunc, this);
        sched_coro->Resume();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7bd7(%rip), %rdi      # 0xb218
callq 0x498e
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0x37a0
movl $0x68, %edi
callq 0x21d0
movq %rax, %r14
leaq 0x1e0(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x2890
movq %r14, 0x1c8(%rbx)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq 0x572(%rip), %rax       # 0x3bfc
movq %rax, (%rsi)
leaq -0xe30(%rip), %rax      # 0x2864
movq %rax, 0x18(%rsi)
leaq -0xe33(%rip), %rax      # 0x286c
movq %rax, 0x10(%rsi)
movq %r14, %rdi
addq $0x18, %rdi
movq %rbx, 0x38(%r14)
callq 0x49ce
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x36ca
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x1c8(%rbx), %rdi
xorl %esi, %esi
callq 0x2afc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x36fe
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x3716
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3716
movq %rax, %rdi
callq 0x2858
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Start()
int Scheduler::Start()
    {
        options.share_stack = CoroType::NewShareStack(options.share_stack_count, options.max_stack_size);
        if (options.create_thread)
        {
            pthread_attr_t attr;
            pthread_attr_init(&attr);
            if (0 != pthread_create(&tid, &attr, RunFunc, this))
            {
                return errno;
            }
        }
        else
        {
            g_current_scheduler.SetValue(this);
            InitCoroPool();
        }
        return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x1e4(%rdi), %esi
movl 0x1f4(%rdi), %edi
callq 0x2d24
movq %rax, 0x200(%rbx)
cmpb $0x1, 0x1e0(%rbx)
jne 0x3779
movq %rsp, %r14
movq %r14, %rdi
callq 0x2230
leaq 0x70(%rbx), %rdi
leaq -0x1cb(%rip), %rdx      # 0x3594
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2350
movl %eax, %ebx
testl %eax, %eax
je 0x3792
callq 0x2040
movl (%rax), %eax
jmp 0x3792
leaq 0x7a98(%rip), %rdi      # 0xb218
callq 0x498e
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0x37a0
jmp 0x3796
testl %ebx, %ebx
jne 0x3798
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::CheckTimeQueue()
int64_t Scheduler::CheckTimeQueue()
    {
        while (!coro_time_queue.empty())
        {
            TimeCoroDiaptchDataQueue::iterator it = coro_time_queue.begin();
            CoroDiaptchDataQueue& queue = it->second;
            int64_t ts = it->first;
            int64_t now = currentMills();
            if (now < ts)
            {
                return ts - now;
            }
            //printf("###time queue size:%d\n", queue.size());
            for (size_t i = 0; i < queue.size(); i++)
            {
                CoroDiaptchData* data = queue[i];
                data->Invoke();
            }
            coro_time_queue.erase(it);
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %r12
movabsq $-0x400000000000000, %r15 # imm = 0xFC00000000000000
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0xf0(%rbx)
je 0x3a2a
movq 0xe0(%rbx), %r13
movq 0x20(%r13), %r14
movq %r12, %rdi
xorl %esi, %esi
callq 0x2300
imulq $0x3e8, 0x18(%rsp), %rcx # imm = 0x3E8
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x20(%rsp)
movq %rdx, %rbp
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rbp
addq %rax, %rbp
addq %rcx, %rbp
movq %r14, %rax
subq %rbp, %rax
jle 0x3963
movq %rax, 0x10(%rsp)
jmp 0x3a1f
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x70(%r13), %rcx
movq 0x50(%r13), %rax
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
shlq $0x6, %rdx
movq 0x58(%r13), %rsi
subq 0x60(%r13), %rsi
sarq $0x3, %rsi
movq 0x38(%r13), %rcx
movq 0x48(%r13), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
addq %rsi, %rdi
addq %rdx, %rdi
cmpq %rdi, %rbx
jae 0x3a04
movq %rcx, %rdx
subq 0x40(%r13), %rdx
sarq $0x3, %rdx
leaq (%rbx,%rdx), %rsi
cmpq $0x3f, %rsi
ja 0x39c6
addq %r12, %rcx
jmp 0x39f0
movq %rsi, %rcx
shrq $0x6, %rcx
leaq (%rcx,%r15), %rdi
testq %rsi, %rsi
cmovgq %rcx, %rdi
movq %rdi, %rcx
shlq $0x6, %rcx
subq %rcx, %rdx
addq %rbx, %rdx
shlq $0x3, %rdx
addq (%rax,%rdi,8), %rdx
movq %rdx, %rcx
movq (%rcx), %rdi
callq 0x4788
incq %rbx
addq $0x8, %r12
jmp 0x3968
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x524c
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbx
leaq 0x18(%rsp), %r12
cmpq %rbp, %r14
jle 0x3902
jmp 0x3a2c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::InvokeQueueSize()
uint32_t Scheduler::InvokeQueueSize()
    {
        uint32_t n = 0;
        coro_queue_mutex.Lock();
        n = coro_queue.size();
        coro_queue_mutex.Unlock();
        return n;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x100(%rdi), %rbx
movq %rbx, %rdi
callq 0x2270
movq 0xc0(%r14), %rax
movl 0xa0(%r14), %ecx
movl %eax, %edx
subl %ecx, %edx
shrl $0x3, %edx
cmpq $0x1, %rax
adcl $-0x1, %edx
shll $0x6, %edx
movq 0x98(%r14), %r15
movq 0xa8(%r14), %rax
subq 0xb0(%r14), %rax
subq 0x88(%r14), %r15
shrq $0x3, %rax
shrq $0x3, %r15
addl %eax, %r15d
addl %edx, %r15d
movq %rbx, %rdi
callq 0x2180
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Routine(bool)
void Scheduler::Routine(bool wait)
    {
        CoroGC();
        while (1)
        {
            CoroDiaptchData* data = NULL;
            {
                coro_queue_mutex.Lock();
                if ((coro_queue.empty()) && wait)
                {
                    if (routine_wait_ms <= 0 || routine_wait_ms > 100)
                    {
                        routine_wait_ms = 10;
                    }
                    //printf("###before wait %d %lld\n", routine_wait_ms, nowMs());
                    coro_queue_mutex.Wait(routine_wait_ms);
                    //printf("###after wait %d %lld %d\n", routine_wait_ms, nowMs(), v);
                }
                if (!coro_queue.empty())
                {
                    data = coro_queue.front();
                    coro_queue.pop_front();
                }
                coro_queue_mutex.Unlock();
            }

            if (NULL == data)
            {
                routine_wait_ms = CheckTimeQueue();
                return;
            }
            else
            {
                data->Invoke();
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3b7e
leaq 0xf8(%r14), %r15
leaq 0x100(%r14), %r12
leaq 0x78(%r14), %r13
xorb $0x1, %bl
movq %r12, %rdi
callq 0x2270
movq 0xa8(%r14), %rax
cmpq 0x88(%r14), %rax
setne %al
orb %bl, %al
jne 0x3b20
movq 0x1d0(%r14), %rax
addq $-0x65, %rax
cmpq $-0x65, %rax
ja 0x3b11
movq $0xa, 0x1d0(%r14)
movq 0x1d0(%r14), %rsi
movq %r15, %rdi
callq 0x4834
movq 0x88(%r14), %rax
cmpq %rax, 0xa8(%r14)
je 0x3b3d
movq (%rax), %rbp
movq %r13, %rdi
callq 0x48da
jmp 0x3b3f
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x2180
testq %rbp, %rbp
je 0x3b56
movq %rbp, %rdi
callq 0x4788
jmp 0x3b65
movq %r14, %rdi
callq 0x38d2
movq %rax, 0x1d0(%r14)
testq %rbp, %rbp
jne 0x3ad8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::StartCoroAfter(std::function<void (void*)> const&, void*, long, bool)
int Scheduler::StartCoroAfter(const CoroutineFunction& func, void* data, int64_t wait_time, bool create_coro)
    {
        if (NULL == g_current_scheduler.GetValue())
        {
            return PushCoroTask(func, data, false, wait_time);
        }
        CoroDiaptchData* task = new CoroDiaptchData;
        task->call = func;
        task->data = data;
        task->create_coro = create_coro;
        AddTimeCoroTask(task, wait_time);
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x754d(%rip), %rdi      # 0xb218
callq 0x498e
cmpq $0x0, (%rax)
je 0x3d14
movl $0x30, %edi
callq 0x21d0
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x19(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x49ce
movq %r14, 0x20(%r13)
movb %bpl, 0x28(%r13)
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3c10
jmp 0x3d27
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x3d38
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::PushCoroTask(std::function<void (void*)> const&, void*, bool, long)
int Scheduler::PushCoroTask(const CoroutineFunction& func, void* data, bool create_coro, int64_t wait_time)
    {
        if (create_coro && IsOverload())
        {
            return -1;
        }
        CoroDiaptchData* task = new CoroDiaptchData;
        task->call = func;
        task->data = data;
        task->create_coro = create_coro;

        coro_queue_mutex.Lock();
        if (wait_time > 0)
        {
            AddTimeCoroTask(task, wait_time);
        }
        else
        {
            coro_queue.push_back(task);
            if (options.eventfd > 0)
            {
                int64_t ev = 1;
                ::write(options.eventfd, &ev, sizeof(ev));
            }
            else
            {
                coro_queue_mutex.Notify();
            }
        }
        coro_queue_mutex.Unlock();
        return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x30, %edi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x19(%rax)
movq %rax, (%rsp)
movq %rax, %rdi
movq %r13, %rsi
callq 0x49ce
movq (%rsp), %rax
movq %r12, 0x20(%rax)
movb %bl, 0x28(%rax)
leaq 0x100(%r14), %rbx
movq %rbx, %rdi
callq 0x2270
testq %r15, %r15
jle 0x3daa
movq (%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3c10
jmp 0x3e10
movq 0xa8(%r14), %rax
movq 0xb8(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3dd2
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0xa8(%r14)
jmp 0x3dde
leaq 0x78(%r14), %rdi
movq %rsp, %rsi
callq 0x5526
movl 0x1f8(%r14), %edi
testl %edi, %edi
jle 0x3e01
leaq 0x8(%rsp), %rsi
movq $0x1, (%rsi)
movl $0x8, %edx
callq 0x20d0
jmp 0x3e10
addq $0x130, %r14            # imm = 0x130
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2180
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::CreateCoroutine(std::function<void (void*)> const&, void*, bool)
CoroPtr Scheduler::CreateCoroutine(const CoroutineFunction& func, void* data, bool pool)
    {
        CoroPtr task = new CoroType(options);
        CoroutineDataContext& data_ctx = task->GetDataContext();
        CoroCallData* cdata = new CoroCallData;
        data_ctx.data = cdata;
        cdata->data = data;
        cdata->coro = task;
        cdata->func = func;
        cdata->scheduler = this;
        if (pool)
        {
            data_ctx.func = CoroutinePoolFunc;
        }
        else
        {
            data_ctx.func = CoroutineNonPoolFunc;
        }

        return task;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x68, %edi
callq 0x21d0
movq %rax, %rbx
leaq 0x1e0(%r14), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x2890
movq %rbx, %r13
addq $0x18, %r13
movl $0x38, %edi
callq 0x21d0
movq %rax, %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
leaq 0x10(%rax), %rdi
movq %rax, 0x38(%rbx)
movq %r12, 0x8(%rax)
movq %rbx, (%rax)
movq %r15, %rsi
callq 0x49ce
movq %r14, 0x30(%rbp)
leaq 0x1b5(%rip), %rax       # 0x405f
leaq 0x20c(%rip), %rsi       # 0x40bd
cmpb $0x0, 0x4(%rsp)
cmovneq %rax, %rsi
movq %r13, %rdi
callq 0x4a9c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x21e0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::CoroDone(coroxx::LibCoroCoroutine*, bool)
void Scheduler::CoroDone(CoroPtr coro, bool pool)
    {
        if (exec_table.erase(coro->id) > 0)
        {
            exec_coro_num--;
        }
        if (pool)
        {
            coro_pool.push_back(coro);
        }
        else
        {
            deleting_coros.push_back(coro);
        }

        /*
         * Wake join coroutine first
         */
        CoroutineTable::iterator jit = join_table.find(coro->id);
        if (jit != join_table.end())
        {
            CoroPtr waiting = jit->second;
            join_table.erase(jit);
            //printf("####Join Resume \n");
            waiting->Resume(true);
        }
        else
        {
            coro->Yield(true);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, (%rsp)
addq $0x38, %rdi
addq $0x10, %rsi
callq 0x584a
testq %rax, %rax
je 0x3f2b
decq 0x1d8(%rbx)
testb %bpl, %bpl
je 0x3f58
movq 0x1a8(%rbx), %rax
movq 0x1b8(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3f79
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x1a8(%rbx)
jmp 0x3f99
movq 0x168(%rbx), %rsi
cmpq 0x170(%rbx), %rsi
je 0x3f8a
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x168(%rbx)
jmp 0x3f99
leaq 0x178(%rbx), %rdi
movq %rsp, %rsi
callq 0x337e
jmp 0x3f99
leaq 0x160(%rbx), %rdi
movq %rsp, %rdx
callq 0x5938
movq (%rsp), %rcx
movq 0x10(%rcx), %r8
addq $0x10, %rcx
xorl %r14d, %r14d
movq %r8, %rax
xorl %edx, %edx
divq 0x8(%rbx)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x5204
testq %rax, %rax
je 0x3fca
movq (%rax), %r14
testq %r14, %r14
je 0x3fed
movq 0x10(%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a58
movq %r15, %rdi
movl $0x1, %esi
callq 0x2afc
jmp 0x3ffb
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x2a98
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::GetCoroutine(std::function<void (void*)> const&, void*)
CoroPtr Scheduler::GetCoroutine(const CoroutineFunction& func, void* data)
    {
        if (coro_pool.empty())
        {
            return CreateCoroutine(func, data, false);
        }
        else
        {
            CoroPtr coro = coro_pool.front();
            coro_pool.pop_front();
            CoroutineDataContext& data_ctx = coro->GetDataContext();
            CoroCallData* cdata = (CoroCallData*) data_ctx.data;
            cdata->data = data;
            cdata->func = func;
            return coro;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x188(%rdi), %rax
cmpq %rax, 0x1a8(%rdi)
je 0x404d
addq $0x178, %rdi            # imm = 0x178
movq (%rax), %r15
callq 0x4a4e
movq 0x38(%r15), %rdi
movq %r14, 0x8(%rdi)
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x49ce
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x3e28
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroutinePoolFunc(void*)
static void CoroutinePoolFunc(void* cdata)
    {
        CoroCallData* data = (CoroCallData*) cdata;
        Scheduler* scheduler = data->scheduler;
        CoroPtr coro = data->coro;
        while (1)
        {
            data->func(data->data);
            scheduler->CoroDone(coro, true);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rdi)
je 0x40b8
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq *0x28(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3f02
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rbx)
jne 0x408f
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::StartCoro(std::function<void (void*)> const&, void*, bool)
coro_id Scheduler::StartCoro(const CoroutineFunction& func, void* data, bool create_coro)
    {
        //start from another thread
        if (NULL == g_current_scheduler.GetValue())
        {
            return PushCoroTask(func, data, create_coro, 0);
        }
        if (IsOverload())
        {
            return (coro_id) -1;
        }
        CoroGC();
        CoroPtr task = GetCoroutine(func, data);
        coro_id id = task->id;
        exec_table[id] = task;
        exec_coro_num++;
        Wakeup(task);
        return id;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70c6(%rip), %rdi      # 0xb218
callq 0x498e
cmpq $0x0, (%rax)
je 0x41a7
movq %rbx, %rdi
callq 0x3b7e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4006
movq %rax, %r14
movq 0x10(%rax), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x5a82
movq %r14, (%rax)
incq 0x1d8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2afc
movq (%r15), %r12
jmp 0x41bf
movzbl %bpl, %ecx
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x3d38
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Join(unsigned long)
int Scheduler::Join(coro_id cid)
    {
        CoroutineTable::iterator it = exec_table.find(cid);
        if (it == exec_table.end())
        {
            return 0;
        }
        it = join_table.find(cid);
        if (it != join_table.end())
        {
            return -2;
        }
        CoroPtr current = CoroType::CurrentCoro();
        join_table[cid] = current;
        Wait(current);
        return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x38(%rdi), %r8
movq 0x40(%rdi), %r9
xorl %ecx, %ecx
movq %rsi, %rax
xorl %edx, %edx
divq %r9
movq %rdx, %rdi
movq (%r8,%rdx,8), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x42ab
movq (%rdx), %r10
movq %rdx, %rax
cmpq %rsi, 0x8(%r10)
je 0x42ab
movq %r10, %r11
movq (%r10), %r10
testq %r10, %r10
je 0x42a9
movq 0x8(%r10), %r8
movq %r8, %rax
xorl %edx, %edx
divq %r9
movl $0x0, %eax
cmpq %rdi, %rdx
jne 0x42ab
movq %r11, %rax
cmpq %rsi, %r8
jne 0x427e
jmp 0x42ab
xorl %eax, %eax
testq %rax, %rax
je 0x4347
cmpq $0x0, (%rax)
je 0x4347
movq (%rbx), %rdi
movq 0x8(%rbx), %r8
xorl %r10d, %r10d
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x4317
movq (%rax), %r9
movq %rax, %r10
cmpq %rsi, 0x8(%r9)
je 0x4317
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x4314
movq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x4317
movq %r11, %r10
cmpq %rsi, %rdi
jne 0x42e8
jmp 0x4317
xorl %r10d, %r10d
testq %r10, %r10
je 0x4327
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmpq $0x0, (%r10)
jne 0x4347
callq 0x2d12
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a82
movq %r14, (%rax)
movq %r14, %rdi
callq 0x2a8c
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Join(unsigned long, unsigned long, unsigned long)
int Scheduler::Join(coro_id c1, coro_id c2, coro_id c3)
    {
        Join(c1);
        Join(c2);
        Join(c3);
        return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x4244
movq %r15, %rdi
movq %r14, %rsi
callq 0x4244
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4244
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::SchedulerManager::Singleton()
SchedulerManager& SchedulerManager::Singleton()
    {
        if (NULL == g_scheduler_manager)
        {
            CoroOptions opt;
            CreateSingleton(opt);
        }
        return *g_scheduler_manager;
    }

// Assembly:
cmpq $0x0, 0x6e5c(%rip)      # 0xb220
jne 0x43fa
subq $0x28, %rsp
movq %rsp, %rdi
movb $0x1, (%rdi)
movaps 0x2c39(%rip), %xmm0     # 0x7010
movups %xmm0, 0x4(%rdi)
movabsq $-0xfffffff0, %rax      # imm = 0xFFFFFFFF00000010
movq %rax, 0x14(%rdi)
movq $0x0, 0x20(%rdi)
callq 0x4402
addq $0x28, %rsp
movq 0x6e1f(%rip), %rax      # 0xb220
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::SchedulerManager::GetRunningCoroNum()
uint32_t SchedulerManager::GetRunningCoroNum()
    {
        if (NULL != g_scheduler_manager)
        {
            return 0;
        }
        uint32_t count = 0;
        for (size_t i = 0; i < g_scheduler_manager->schedulers_.size(); i++)
        {
            count += g_scheduler_manager->schedulers_[i]->GetCoroNum();
        }
        return count;
    }

// Assembly:
movq 0x6dbf(%rip), %rdx      # 0xb220
xorl %eax, %eax
testq %rdx, %rdx
jne 0x44a9
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
je 0x44a9
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movq 0x168(%rdi), %r8
subq 0x160(%rdi), %r8
shrq $0x3, %r8
addl 0x50(%rdi), %r8d
addl %r8d, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x4484
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::SchedulerManager::GetScheduler()
Scheduler& SchedulerManager::GetScheduler()
    {
        Scheduler* s = g_current_scheduler.GetValue();
        if (NULL != s)
        {
            return *s;
        }
        uint32_t min_coro_num = 0;
        uint32_t min_scheduler_idx = 0;
        SchedulerManager& singleton = SchedulerManager::Singleton();
        if (singleton.schedulers_.size() > 1)
        {
            for (size_t i = 0; i < singleton.schedulers_.size(); i++)
            {
                uint32_t numk = singleton.schedulers_[i]->GetCoroNum();
                if (0 == numk)
                {
                    min_scheduler_idx = i;
                    break;
                }
                if (numk < min_coro_num)
                {
                    min_coro_num = numk;
                    min_scheduler_idx = i;
                }
            }
        }
        return *(singleton.schedulers_[min_scheduler_idx]);
    }

// Assembly:
pushq %rax
leaq 0x6ca4(%rip), %rdi      # 0xb218
callq 0x498e
movq (%rax), %rax
testq %rax, %rax
jne 0x45d6
callq 0x43bc
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
xorl %edx, %edx
cmpq $0x2, %rax
jb 0x45d2
decq %rax
xorl %esi, %esi
movl %edx, %edi
movq (%rcx,%rsi,8), %r8
movq 0x168(%r8), %r9
subq 0x160(%r8), %r9
shrq $0x3, %r9
movl %esi, %edx
addl 0x50(%r8), %r9d
cmovnel %edi, %edx
je 0x45d0
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rax
movq %rdi, %rsi
jne 0x45a1
movl %edx, %edx
movq (%rcx,%rdx,8), %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroDiaptchData::Invoke()
void Invoke()
            {
                if (create_coro)
                {
                    StartCoro(CoroDiaptchData::InvokeFunc, this);
                }
                else
                {
                    CoroDiaptchData::InvokeFunc(this);
                }
            }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x47fa
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x717(%rip), %rax       # 0x4ec0
movq %rax, (%rsp)
leaq -0x1f50(%rip), %rax     # 0x2864
movq %rax, 0x18(%rsp)
leaq -0x1f54(%rip), %rax     # 0x286c
movq %rax, 0x10(%rsp)
callq 0x456c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x4134
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x47f4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x4ec0
jmp 0x482b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x4823
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x2858
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/./thread_mutex_lock.h
// Function: coroxx::ThreadMutexLock::Wait(unsigned long)
bool Wait(uint64_t timeout = 0)
            {
                if (timeout <= 0)
                {
                    return 0 == pthread_cond_wait(&m_cond, &m_mutex);
                }
                else
                {
                    struct timeval tp;
                    struct timespec ts;
                    gettimeofday(&tp, NULL);
                    int64_t now_micros = ((int64_t) tp.tv_sec) * 1000*1000 + tp.tv_usec;
                    setWaitTime(&ts, now_micros, timeout);
                    return 0 == pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x48ba
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2300
imulq $0xf4240, (%r15), %rax  # imm = 0xF4240
addq 0x8(%r15), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
imulq $0xf4240, %r14, %rcx    # imm = 0xF4240
addq %rax, %rcx
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rsp, %rax
movq %rdx, (%rax)
imulq $0x3b9aca00, %rdx, %rdx # imm = 0x3B9ACA00
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x22b0
jmp 0x48ca
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x22d0
testl %eax, %eax
sete %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/./thread_local.h
// Function: coroxx::ThreadLocal<coroxx::Scheduler*>::GetValue()
T*& GetValue()
			{
				T** local_thread_value = static_cast<T**>(pthread_getspecific(
				        m_key));
				if (NULL == local_thread_value)
				{
					T** newObj = InitialValue();
					pthread_setspecific(m_key, newObj);
					local_thread_value = newObj;
				}
				return *local_thread_value;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x22c0
movq %rax, %r14
testq %rax, %rax
jne 0x49c2
movl $0x8, %edi
callq 0x21d0
movq %rax, %r14
movq $0x0, (%rax)
movl (%rbx), %edi
movq %rax, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroDiaptchData::InvokeFunc(void*)
static void InvokeFunc(void* data)
            {
                CoroDiaptchData* v = (CoroDiaptchData*) data;
                if (NULL != v && v->call)
                {
                    v->call(v->data);
                    delete v;
                }
            }

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4f09
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x4f09
movq 0x20(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4efc
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movl $0x30, %esi
movq %rbx, %rdi
callq 0x21e0
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x2858
nop
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/coro.c
// Function: coro_stack_alloc
int
coro_stack_alloc (struct coro_stack *stack, unsigned int size)
{
  if (!size)
    size = 256 * 1024;

  stack->sptr = 0;
  stack->ssze = ((size_t)size * sizeof (void *) + PAGESIZE - 1) / PAGESIZE * PAGESIZE;

#if CORO_FIBER

  stack->sptr = (void *)stack;
  return 1;

#else

  size_t ssze = stack->ssze + CORO_GUARDPAGES * PAGESIZE;
  void *base;

  #if CORO_MMAP
    /* mmap supposedly does allocate-on-write for us */
    base = mmap (0, ssze, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (base == (void *)-1)
      {
        /* some systems don't let us have executable heap */
        /* we assume they won't need executable stack in that case */
        base = mmap (0, ssze, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (base == (void *)-1)
          return 0;
      }

    #if CORO_GUARDPAGES
      mprotect (base, CORO_GUARDPAGES * PAGESIZE, PROT_NONE);
    #endif

    base = (void*)((char *)base + CORO_GUARDPAGES * PAGESIZE);
  #else
    base = malloc (ssze);
    if (!base)
      return 0;
  #endif

  #if CORO_USE_VALGRIND
    stack->valgrind_id = VALGRIND_STACK_REGISTER ((char *)base, ((char *)base) + ssze - CORO_GUARDPAGES * PAGESIZE);
  #endif

  stack->sptr = base;
  return 1;

#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
movl $0x40000, %r14d         # imm = 0x40000
cmovnel %esi, %r14d
movq $0x0, (%rdi)
shlq $0x3, %r14
cmpq $0x0, 0x52f6(%rip)      # 0xb248
jne 0x5f65
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x52e3(%rip)      # 0xb248
movq 0x52dc(%rip), %rax      # 0xb248
addq %rax, %r14
decq %r14
testq %rax, %rax
jne 0x5f88
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x52c0(%rip)      # 0xb248
movq 0x52b9(%rip), %rcx      # 0xb248
xorl %r15d, %r15d
movq %r14, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0x8(%rbx)
leaq (%r14,%rcx,4), %r12
xorl %edi, %edi
movq %r12, %rsi
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x2340
cmpq $-0x1, %rax
jne 0x5feb
xorl %edi, %edi
movq %r12, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x2340
cmpq $-0x1, %rax
je 0x604d
movq %rax, %r14
cmpq $0x0, 0x5252(%rip)      # 0xb248
jne 0x6009
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x523f(%rip)      # 0xb248
movq 0x5238(%rip), %rsi      # 0xb248
shlq $0x2, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x22f0
cmpq $0x0, 0x5222(%rip)      # 0xb248
jne 0x6039
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x520f(%rip)      # 0xb248
movq 0x5208(%rip), %rax      # 0xb248
leaq (%r14,%rax,4), %rax
movq %rax, (%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/coro.c
// Function: coro_stack_free
void
coro_stack_free (struct coro_stack *stack)
{
#if CORO_FIBER
  /* nop */
#else
  #if CORO_USE_VALGRIND
    VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
  #endif

  #if CORO_MMAP
    if (stack->sptr)
      munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
              stack->ssze                 + CORO_GUARDPAGES * PAGESIZE);
  #else
    free (stack->sptr);
  #endif
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x60cc
movq %rdi, %r14
cmpq $0x0, 0x51d5(%rip)      # 0xb248
jne 0x6086
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x51c2(%rip)      # 0xb248
movq 0x51bb(%rip), %rax      # 0xb248
leaq (,%rax,4), %rcx
subq %rcx, %rbx
movq 0x8(%r14), %r14
testq %rax, %rax
jne 0x60b2
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x5196(%rip)      # 0xb248
movq 0x518f(%rip), %rax      # 0xb248
leaq (%r14,%rax,4), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rthoelen[P]NXCore_Kenwood/main.cc
// Function: rpton_64001(int)
void rpton_64001(int rpt_no)
{
		int o_bufsize;

		up_packet[24] = (char)repeater[rpt_no].tx_ran;
		while(tx_sem==1)
			usleep(1);
		tx_sem=1;
		sendto(socket_01, up_packet, sizeof(up_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		 	sizeof(repeater[rpt_no].rpt_addr_01));
		tx_sem=0;
		while(1)
		{
			#ifdef __FreeBSD__
			ioctl(socket_01,FIONWRITE,&o_bufsize);
			#else
			ioctl(socket_01,SIOCOUTQ,&o_bufsize);
			#endif
			if(o_bufsize == 0)
				break;
			usleep(500);
		}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xf2a6(%rip), %rax      # 0x153d0
movslq %edi, %rcx
leaq (%rcx,%rcx,8), %rbx
shlq $0x4, %rbx
movb 0x48(%rax,%rbx), %al
movb %al, 0xf239(%rip)       # 0x15378
cmpl $0x1, 0xf2be(%rip)      # 0x15404
jne 0x6154
movl $0x1, %edi
callq 0x4450
jmp 0x613f
movl $0x1, 0xf2a6(%rip)      # 0x15404
movl 0xf29c(%rip), %edi      # 0x15400
movq 0xf265(%rip), %rax      # 0x153d0
leaq (%rax,%rbx), %r8
addq $0x10, %r8
leaq 0xf1e6(%rip), %rsi      # 0x15360
movl $0x1c, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x4060
movl $0x0, 0xf26e(%rip)      # 0x15404
movl 0xf264(%rip), %edi      # 0x15400
leaq -0xc(%rbp), %rbx
movl $0x5411, %esi           # imm = 0x5411
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4430
cmpl $0x0, (%rbx)
je 0x61d9
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x4450
movl 0xf23c(%rip), %edi      # 0x15400
movl $0x5411, %esi           # imm = 0x5411
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4430
cmpl $0x0, -0xc(%rbp)
jne 0x61b4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rthoelen[P]NXCore_Kenwood/main.cc
// Function: shutdown_64001(int)
void shutdown_64001(int rpt_no)
{

	down_packet[12] = (char)(repeater[rpt_no].tx_uid >> 8);
	down_packet[13] = (char)repeater[rpt_no].tx_uid & 0xff;

	while(tx_sem==1)
		usleep(1);

	tx_sem=1;
	sendto(socket_01, down_packet, sizeof(down_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		sizeof(repeater[rpt_no].rpt_addr_01));
	tx_sem=0;

	if(--repeater[rpt_no].keydown < 0)
		repeater[rpt_no].keydown = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xef88(%rip), %rax      # 0x153d0
movslq %edi, %rbx
leaq (%rbx,%rbx,8), %rcx
shlq $0x4, %rcx
movb 0x6d(%rax,%rcx), %dl
movb %dl, 0xef2f(%rip)       # 0x1538c
movb 0x6c(%rax,%rcx), %al
movb %al, 0xef26(%rip)       # 0x1538d
cmpl $0x1, 0xef96(%rip)      # 0x15404
jne 0x647c
movl $0x1, %edi
callq 0x4450
jmp 0x6467
movl $0x1, 0xef7e(%rip)      # 0x15404
movl 0xef74(%rip), %edi      # 0x15400
movq 0xef3d(%rip), %rax      # 0x153d0
shlq $0x4, %rbx
leaq (%rbx,%rbx,8), %rbx
leaq (%rax,%rbx), %r8
addq $0x10, %r8
leaq 0xeed6(%rip), %rsi      # 0x15380
xorl %r14d, %r14d
movl $0x14, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x4060
movl %r14d, 0xef3e(%rip)     # 0x15404
movq 0xef03(%rip), %rax      # 0x153d0
movl 0x74(%rax,%rbx), %ecx
leal -0x1(%rcx), %edx
testl %ecx, %ecx
cmovlel %r14d, %edx
movl %edx, 0x74(%rax,%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/siolag161[P]louvain-original/main_hierarchy.cpp
// Function: usage(char*, char const*)
void
usage(char *prog_name, const char *more) {
  cerr << more;
  cerr << "usage: " << prog_name << " input_file [options]" << endl << endl;
  cerr << "input_file: read the community tree from this file." << endl;
  cerr << "-l xx\t display the community structure for the level xx." << endl;
  cerr << "\t outputs the community for each node." << endl;
  cerr << "\t xx must belong to [-1,N] if N is the number of levels." << endl;
  cerr << "-n\t displays the number of levels and the size of each level." << endl;
  cerr << "\t equivalent to -l -1." << endl;
  cerr << "-h\tshow this usage message." << endl;
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2cd6(%rip), %rbx      # 0x3ff0
movq %rbx, %rdi
callq 0x1100
leaq 0xcdb(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
leaq 0xcc9(%rip), %rsi       # 0x200c
movq %rax, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1060
leaq 0xcc0(%rip), %rsi       # 0x2022
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xcdd(%rip), %rsi       # 0x2056
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xcff(%rip), %rsi       # 0x208f
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xd0f(%rip), %rsi       # 0x20b6
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xd31(%rip), %rsi       # 0x20ef
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xd58(%rip), %rsi       # 0x212d
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xd58(%rip), %rsi       # 0x2144
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1060
xorl %edi, %edi
callq 0x1150