LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x11a59(%rip), %rdi     # 0x18218
callq 0x7d60
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x67ea
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %r8
xorl %ecx, %ecx
callq 0x6880
movl %eax, -0x4(%rbp)
jmp 0x6869
movl $0x30, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x7dc0
jmp 0x6805
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7df0
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6730
movl $0x0, -0x4(%rbp)
jmp 0x6869
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x30, %esi
callq 0x21e0
jmp 0x6872
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2330
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x21(%rbp)
je 0x68c8
movq -0x58(%rbp), %rdi
callq 0x6b20
testb $0x1, %al
jne 0x68bc
jmp 0x68c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x69c0
movl $0x30, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x7dc0
jmp 0x68e3
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7df0
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movb -0x21(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
addq $0xf8, %rdi
callq 0x79f0
cmpq $0x0, -0x30(%rbp)
jle 0x6957
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6730
jmp 0x69a9
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x30, %esi
callq 0x21e0
jmp 0x69c9
movq -0x58(%rbp), %rdi
addq $0x78, %rdi
leaq -0x38(%rbp), %rsi
callq 0x7d00
movq -0x58(%rbp), %rax
cmpl $0x0, 0x1f8(%rax)
jle 0x6997
movq -0x58(%rbp), %rax
movq $0x1, -0x50(%rbp)
movl 0x1f8(%rax), %edi
leaq -0x50(%rbp), %rsi
movl $0x8, %edx
callq 0x20d0
jmp 0x69a7
movq -0x58(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7e70
jmp 0x69a9
movq -0x58(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7a20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x68, %edi
callq 0x21d0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
addq $0x1e0, %rsi            # imm = 0x1E0
xorl %edx, %edx
callq 0x30b0
jmp 0x6a2b
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x80f0
movq %rax, -0x40(%rbp)
movl $0x38, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x8110
jmp 0x6a5b
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x7df0
movq -0x58(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x30(%rax)
testb $0x1, -0x19(%rbp)
je 0x6af3
movq -0x40(%rbp), %rdi
leaq 0x28c(%rip), %rsi       # 0x6d40
callq 0x8150
jmp 0x6b03
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x68, %esi
callq 0x21e0
jmp 0x6b0d
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x38, %esi
callq 0x21e0
jmp 0x6b0d
movq -0x40(%rbp), %rdi
leaq 0x2a2(%rip), %rsi       # 0x6da0
callq 0x8150
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x7f40
cmpq $0x0, %rax
jbe 0x6bcc
movq -0x48(%rbp), %rax
movq 0x1d8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x1d8(%rax)
testb $0x1, -0x11(%rbp)
je 0x6be8
movq -0x48(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
leaq -0x10(%rbp), %rsi
callq 0x5860
jmp 0x6bfc
movq -0x48(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
leaq -0x10(%rbp), %rsi
callq 0x7f70
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x77a0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x7800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7fe0
testb $0x1, %al
jne 0x6c31
jmp 0x6c6b
leaq -0x20(%rbp), %rdi
callq 0x7830
movq -0x48(%rbp), %rdi
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x8010
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3460
jmp 0x6c79
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x33d0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x178, %rdi            # imm = 0x178
callq 0x5650
testb $0x1, %al
jne 0x6cae
jmp 0x6cc7
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x69e0
movq %rax, -0x8(%rbp)
jmp 0x6d2c
movq -0x40(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x8050
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x178, %rdi            # imm = 0x178
callq 0x8080
movq -0x28(%rbp), %rdi
callq 0x80f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x7df0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5580
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x6b80
jmp 0x6d6b
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroutineNonPoolFunc(void*)
static void CoroutineNonPoolFunc(void* cdata)
    {
        CoroCallData* data = (CoroCallData*) cdata;
        Scheduler* scheduler = data->scheduler;
        CoroPtr coro = data->coro;
        if (data->func)
        {
            data->func(data->data);
        }
        else
        {
            abort();
        }
        delete data;
        scheduler->CoroDone(coro, false);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x94d0
testb $0x1, %al
jne 0x6dde
jmp 0x6df5
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5580
jmp 0x6dfa
callq 0x2378
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6e1f
movq -0x28(%rbp), %rdi
callq 0x9590
movq -0x28(%rbp), %rdi
movl $0x38, %esi
callq 0x21e0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x6b80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x113ae(%rip), %rdi     # 0x18218
callq 0x7d60
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x6ea2
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
xorl %ecx, %ecx
movl %ecx, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0x6880
cltq
movq %rax, -0x8(%rbp)
jmp 0x6f2c
movq -0x40(%rbp), %rdi
callq 0x6b20
testb $0x1, %al
jne 0x6eb1
jmp 0x6ebb
movq $-0x1, -0x8(%rbp)
jmp 0x6f2c
movq -0x40(%rbp), %rdi
callq 0x6640
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6c80
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0x81a0
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdi
movq %rcx, (%rax)
movq 0x1d8(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x1d8(%rdi)
movq -0x30(%rbp), %rsi
callq 0x6b30
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::GetCoroById(unsigned long)
CoroPtr Scheduler::GetCoroById(coro_id id)
    {
        CoroutineTable::iterator found = exec_table.find(id);
        if (found != exec_table.end())
        {
            return found->second;
        }
        return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x77a0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x7800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7fe0
testb $0x1, %al
jne 0x6f8d
jmp 0x6fa0
leaq -0x20(%rbp), %rdi
callq 0x7830
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fa8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x77a0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x7800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x77d0
testb $0x1, %al
jne 0x700d
jmp 0x7016
movl $0x0, -0x4(%rbp)
jmp 0x7091
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x77a0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x7800
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7fe0
testb $0x1, %al
jne 0x704f
jmp 0x7058
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x7091
callq 0x3740
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x81a0
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdi
movq %rcx, (%rax)
movq -0x40(%rbp), %rsi
callq 0x6b60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6fc0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6fc0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6fc0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
cmpq 0x1109f(%rip), %rax     # 0x18220
jne 0x7195
leaq -0x28(%rbp), %rdi
callq 0x2bc0
leaq -0x28(%rbp), %rdi
callq 0x71b0
movq 0x11084(%rip), %rax     # 0x18220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::SchedulerManager::CreateSingleton(coroxx::CoroOptions const&)
int SchedulerManager::CreateSingleton(const CoroOptions& opt)
    {
        if (NULL != g_scheduler_manager)
        {
            return -1;
        }
        g_scheduler_manager = new SchedulerManager(opt);
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq 0x1105b(%rip), %rax     # 0x18220
je 0x71d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x721f
movl $0x18, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x72d0
jmp 0x71ef
movq -0x28(%rbp), %rax
movq %rax, 0x11026(%rip)     # 0x18220
movl $0x0, -0x4(%rbp)
jmp 0x721f
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x21e0
jmp 0x7228
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
cmpq 0x10fcf(%rip), %rax     # 0x18220
je 0x725c
movl $0x0, -0x4(%rbp)
jmp 0x72bd
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10fa6(%rip), %rdi     # 0x18220
callq 0x81d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x72b7
movq 0x10f8e(%rip), %rdi     # 0x18220
movq -0x10(%rbp), %rsi
callq 0x81f0
movq (%rax), %rdi
callq 0x8210
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x726b
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::SchedulerManager::SchedulerManager(coroxx::CoroOptions const&)
SchedulerManager::SchedulerManager(const CoroOptions& opt)
    {
        for (uint32_t i = 0; i < opt.sheduler_num; i++)
        {
            Scheduler* s = new Scheduler(opt);
            schedulers_.push_back(s);
            schedulers_[i]->Start();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8260
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x7389
movl $0x208, %edi            # imm = 0x208
callq 0x21d0
movq %rax, -0x40(%rbp)
jmp 0x7314
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8280
jmp 0x7323
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x83d0
jmp 0x733a
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x81f0
movq (%rax), %rdi
callq 0x61a0
jmp 0x7352
jmp 0x7354
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x72f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x738f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x21e0
jmp 0x738f
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8440
movq -0x28(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10e59(%rip), %rdi     # 0x18218
callq 0x7d60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x73e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x748f
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x7170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x81d0
cmpq $0x1, %rax
jbe 0x747a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x81d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x7478
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x81f0
movq (%rax), %rdi
callq 0x8210
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl -0x2c(%rbp), %eax
jne 0x7453
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
jmp 0x7478
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x7468
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
jmp 0x746a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x740e
jmp 0x747a
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x81f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroDiaptchData::Invoke()
void Invoke()
            {
                if (create_coro)
                {
                    StartCoro(CoroDiaptchData::InvokeFunc, this);
                }
                else
                {
                    CoroDiaptchData::InvokeFunc(this);
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x28(%rax)
je 0x798f
leaq 0x1b0f(%rip), %rsi      # 0x9460
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2c10
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x74d0
jmp 0x796d
leaq -0x28(%rbp), %rdi
callq 0x2ca0
jmp 0x7998
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2ca0
jmp 0x799e
movq -0x40(%rbp), %rdi
callq 0x9460
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x7ac7
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x22d0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7b2a
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2300
movq -0x48(%rbp), %rdi
imulq $0x3e8, -0x28(%rbp), %rax # imm = 0x3E8
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq 0x9520
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x8, %rdi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdx
callq 0x22b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %edi
callq 0x22c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x7dae
movq -0x20(%rbp), %rdi
callq 0xc390
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl (%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x2080
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x94c3
movq -0x10(%rbp), %rdi
callq 0x94d0
testb $0x1, %al
jne 0x948b
jmp 0x94c3
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5580
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x94c1
movq -0x18(%rbp), %rdi
callq 0x9500
movq -0x18(%rbp), %rdi
movl $0x30, %esi
callq 0x21e0
jmp 0x94c3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xe50c
movl $0x40000, -0x14(%rbp)   # imm = 0x40000
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
shlq $0x3, %rax
movq %rax, -0x48(%rbp)
callq 0xe650
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0xe650
movq %rax, %rcx
movq -0x40(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
callq 0xe650
movq -0x38(%rbp), %rcx
imulq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0xe650
movq %rax, %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x2340
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0xe5f5
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x2340
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0xe5f3
movl $0x0, -0x4(%rbp)
jmp 0xe645
jmp 0xe5f5
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0xe650
movq -0x58(%rbp), %rdi
movq %rax, %rsi
shlq $0x2, %rsi
xorl %edx, %edx
callq 0x22f0
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xe650
movq %rax, %rcx
movq -0x50(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe6e2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xe650
movq %rax, %rdx
movq -0x20(%rbp), %rax
shlq $0x2, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0xe650
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rsi
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x22a8e(%rip), %rax     # 0x2a520
movslq -0x4(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movb 0x48(%rax), %al
movb %al, 0x22a0f(%rip)      # 0x2a4b8
cmpl $0x1, 0x22aa4(%rip)     # 0x2a554
jne 0x7abe
movl $0x1, %edi
callq 0x5660
jmp 0x7aa9
movl $0x1, 0x22a8c(%rip)     # 0x2a554
movl 0x22a82(%rip), %edi     # 0x2a550
movq 0x22a4b(%rip), %r8      # 0x2a520
movslq -0x4(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %r8
addq $0x10, %r8
leaq 0x229b2(%rip), %rsi     # 0x2a4a0
movl $0x1c, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x5090
movl $0x0, 0x22a4a(%rip)     # 0x2a554
movl 0x22a40(%rip), %edi     # 0x2a550
movl $0x5411, %esi           # imm = 0x5411
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x5640
cmpl $0x0, -0x8(%rbp)
jne 0x7b28
jmp 0x7b34
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x5660
jmp 0x7b0a
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x2264e(%rip), %rax     # 0x2a520
movslq -0x4(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movl 0x6c(%rax), %eax
sarl $0x8, %eax
movb %al, 0x225e0(%rip)      # 0x2a4cc
movq 0x2262d(%rip), %rax     # 0x2a520
movslq -0x4(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movl 0x6c(%rax), %eax
movsbl %al, %eax
andl $0xff, %eax
movb %al, 0x225bb(%rip)      # 0x2a4cd
cmpl $0x1, 0x2263b(%rip)     # 0x2a554
jne 0x7f27
movl $0x1, %edi
callq 0x5660
jmp 0x7f12
movl $0x1, 0x22623(%rip)     # 0x2a554
movl 0x22619(%rip), %edi     # 0x2a550
movq 0x225e2(%rip), %r8      # 0x2a520
movslq -0x4(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %r8
addq $0x10, %r8
leaq 0x22569(%rip), %rsi     # 0x2a4c0
movl $0x14, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x5090
movl $0x0, 0x225e1(%rip)     # 0x2a554
movq 0x225a6(%rip), %rcx     # 0x2a520
movslq -0x4(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
movl 0x74(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x74(%rcx)
cmpl $0x0, %eax
jge 0x7fb2
movq 0x22583(%rip), %rax     # 0x2a520
movslq -0x4(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x74(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x5cb5(%rip), %rdi      # 0x6ff0
callq 0x10e0
movq 0x5ca9(%rip), %rdi      # 0x6ff0
leaq 0x2cb6(%rip), %rsi      # 0x4004
callq 0x10e0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x10e0
movq %rax, %rdi
leaq 0x2ca3(%rip), %rsi      # 0x400c
callq 0x10e0
movq %rax, %rdi
movq 0x5c48(%rip), %rsi      # 0x6fc0
callq 0x1110
movq %rax, %rdi
movq 0x5c39(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5c5d(%rip), %rdi      # 0x6ff0
leaq 0x2c88(%rip), %rsi      # 0x4022
callq 0x10e0
movq %rax, %rdi
movq 0x5c17(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5c3b(%rip), %rdi      # 0x6ff0
leaq 0x2c9a(%rip), %rsi      # 0x4056
callq 0x10e0
movq %rax, %rdi
movq 0x5bf5(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5c19(%rip), %rdi      # 0x6ff0
leaq 0x2cb1(%rip), %rsi      # 0x408f
callq 0x10e0
movq %rax, %rdi
movq 0x5bd3(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5bf7(%rip), %rdi      # 0x6ff0
leaq 0x2cb6(%rip), %rsi      # 0x40b6
callq 0x10e0
movq %rax, %rdi
movq 0x5bb1(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5bd5(%rip), %rdi      # 0x6ff0
leaq 0x2ccd(%rip), %rsi      # 0x40ef
callq 0x10e0
movq %rax, %rdi
movq 0x5b8f(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5bb3(%rip), %rdi      # 0x6ff0
leaq 0x2ce9(%rip), %rsi      # 0x412d
callq 0x10e0
movq %rax, %rdi
movq 0x5b6d(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x5b91(%rip), %rdi      # 0x6ff0
leaq 0x2cde(%rip), %rsi      # 0x4144
callq 0x10e0
movq %rax, %rdi
movq 0x5b4b(%rip), %rsi      # 0x6fc0
callq 0x1110
xorl %edi, %edi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: siolag161[P]louvain-original/main_hierarchy.cpp
// Function: parse_args(int, char**)
void
parse_args(int argc, char **argv) {
  if (argc<2)
    usage(argv[0], "Bad arguments number\n");

  for (int i = 1; i < argc; i++) {
    if(argv[i][0] == '-') {
      switch(argv[i][1]) {
      case 'l':
	display_level = atoi(argv[i+1]);
	i++;
	break;
      case 'n':
	display_level = -1;
	break;
      default:
	usage(argv[0], "Unknown option\n");
      }
    } else {
      if (filename==NULL)
        filename = argv[i];
      else
        usage(argv[0], "More than one filename\n");
    }
  }
  if (filename==NULL)
    usage(argv[0], "No input file has been provided.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x14b8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x2cad(%rip), %rsi      # 0x4160
callq 0x1320
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x158f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x154b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x6c, %eax
je 0x1503
jmp 0x14f9
movl -0x18(%rbp), %eax
subl $0x6e, %eax
je 0x152a
jmp 0x1536
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1180
movl %eax, 0x5be1(%rip)      # 0x7100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1549
movl $0xffffffff, 0x5bcc(%rip) # imm = 0xFFFFFFFF
jmp 0x1549
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x2c32(%rip), %rsi      # 0x4176
callq 0x1320
jmp 0x157f
cmpq $0x0, 0x5bcd(%rip)      # 0x7120
jne 0x156a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x5bb8(%rip)      # 0x7120
jmp 0x157d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x2c0e(%rip), %rsi      # 0x4186
callq 0x1320
jmp 0x157f
jmp 0x1581
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14bf
cmpq $0x0, 0x5b89(%rip)      # 0x7120
jne 0x15ac
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x2bf7(%rip), %rsi      # 0x419e
callq 0x1320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/src/service_registry/service_registry.cpp
// Function: Boss::ServiceRegistry::GetServiceInfo(unsigned int, Boss::IServiceInfo**) const
RetCode BOSS_CALL ServiceRegistry::GetServiceInfo(ClassId clsId, IServiceInfo **info) const
  {
    if (!info || *info)
      return Status::InvalidArgument;
    
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      auto Iter = Services.find(clsId);
      return Iter != std::end(Services) ? Iter->second.QueryInterface(info) : Status::NotFound;
    }
    catch (...)
    {
    }
    return Status::Fail;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1f44f
movq 0x48(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f45c
movl $0x5, 0x64(%rsp)
jmp 0x1f54f
movq 0x18(%rsp), %rsi
addq $0x28, %rsi
leaq 0x40(%rsp), %rdi
callq 0x22340
jmp 0x1f471
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
leaq 0x54(%rsp), %rsi
callq 0x22370
movq %rax, 0x10(%rsp)
jmp 0x1f48b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x50, %rdi
callq 0x223c0
movq %rax, 0x8(%rsp)
jmp 0x1f4aa
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x223a0
testb $0x1, %al
jne 0x1f4c9
jmp 0x1f4f3
leaq 0x28(%rsp), %rdi
callq 0x223f0
movq %rax, %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x22410
movl %eax, 0x4(%rsp)
jmp 0x1f4ea
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
jmp 0x1f4fd
movl $0x3, %eax
movl %eax, (%rsp)
jmp 0x1f4fd
movl (%rsp), %eax
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x22460
jmp 0x1f54f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1f538
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x22460
movq 0x38(%rsp), %rdi
callq 0x480e0
callq 0x48150
movl $0x2, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: tdv[P]boss/boss/src/service_registry/service_registry.cpp
// Function: Boss::ServiceRegistry::DelService(unsigned int)
RetCode BOSS_CALL ServiceRegistry::DelService(ServiceId serviceId)
  {
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      typedef std::vector<ClassId> ClassIdPool;
      ClassIdPool ClassIds;
      for (auto const &i : Services)
      {
        ServiceId SrvId = 0;
        RetCode Res = i.second->GetServiceId(&SrvId);
        if (Res != Status::Ok)
          return Res;
        ClassIds.push_back(i.first);
      }
      for (auto const &i : ClassIds)
        Services.erase(i);
    }
    catch (...)
    {
      return Status::Fail;
    }
    return Status::Ok;
  }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq 0xa8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x28, %rsi
leaq 0x98(%rsp), %rdi
callq 0x22340
jmp 0x1fdc6
leaq 0x70(%rsp), %rdi
callq 0x22630
movq 0x18(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x22940
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x22970
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x223a0
testb $0x1, %al
jne 0x1fe14
jmp 0x1ff11
leaq 0x60(%rsp), %rdi
callq 0x229a0
movq %rax, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
callq 0x22c70
movq %rax, 0x10(%rsp)
jmp 0x1fe40
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0x4c(%rsp), %rsi
callq *%rax
movl %eax, 0xc(%rsp)
jmp 0x1fe59
movl 0xc(%rsp), %eax
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
je 0x1feef
movl 0x48(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0x1ff88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1fec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x22bc0
leaq 0x98(%rsp), %rdi
callq 0x22460
movq 0x90(%rsp), %rdi
callq 0x480e0
movl $0x2, 0xb4(%rsp)
movl $0x1, 0x44(%rsp)
callq 0x48150
jmp 0x1ffb8
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x22700
jmp 0x1ff00
jmp 0x1ff02
leaq 0x60(%rsp), %rdi
callq 0x22a20
jmp 0x1fdfc
leaq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22a50
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22a80
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x22ab0
testb $0x1, %al
jne 0x1ff4e
jmp 0x1ff80
leaq 0x30(%rsp), %rdi
callq 0x22af0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
callq 0x22c80
jmp 0x1ff72
jmp 0x1ff74
leaq 0x30(%rsp), %rdi
callq 0x22ba0
jmp 0x1ff39
movl $0x0, 0x44(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x22bc0
leaq 0x98(%rsp), %rdi
callq 0x22460
movl 0x44(%rsp), %eax
testl %eax, %eax
je 0x1ffab
jmp 0x1ffa9
jmp 0x1ffb8
jmp 0x1ffad
movl $0x0, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
// File: tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::Private::ServiceInfo<Boss::ILocalServiceInfo, true>::AddCoClassIds(Boss::RefObjPtr<Boss::IEnum>)
void AddCoClassIds(RefObjPtr<IEnum> coClassIds)
      {
        if (!coClassIds.Get())
          return;
        if (!CoClassIds.Get())
          CoClassIds = Base<Enum>::Create();
        coClassIds->Reset();
        for (RefObjPtr<IBase> i ; coClassIds->Next(i.GetPPtr()) == Status::Ok ; i.Release())
          CoClassIds->AddItem(i);
      }

// Assembly:
subq $0x78, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rax
movq 0x28(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq %rax, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x24080
cmpq $0x0, %rax
jne 0x231fa
jmp 0x23348
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
callq 0x24260
cmpq $0x0, %rax
jne 0x2325b
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x23c80
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x18, %rdi
callq 0x3df60
jmp 0x23232
leaq 0x60(%rsp), %rdi
callq 0x24300
jmp 0x2325b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x24300
jmp 0x2334d
movq 0x30(%rsp), %rdi
callq 0x22640
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22dc0
movq 0x30(%rsp), %rdi
callq 0x22640
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x22e00
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x232ac
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
je 0x232d4
leaq 0x48(%rsp), %rdi
callq 0x23860
jmp 0x23348
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2333c
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
callq 0x23e60
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2dc90
jmp 0x232f8
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x37910
jmp 0x23309
leaq 0x40(%rsp), %rdi
callq 0x23860
leaq 0x48(%rsp), %rdi
callq 0x25370
jmp 0x2331f
jmp 0x2327c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x23860
leaq 0x48(%rsp), %rdi
callq 0x23860
jmp 0x2334d
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xf31f0
nopw (%rax,%rax)
// File: tdv[P]boss/boss/include/common/entity_id.h
// Function: Boss::EntityId::GetId(unsigned int*) const
virtual RetCode BOSS_CALL GetId(UInt *id) const
    {
      if (!id)
        return Status::InvalidArgument;
      *id = Id;
      return Status::Ok;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x26e66
movl $0x5, -0x4(%rsp)
jmp 0x26e7d
movq -0x20(%rsp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)