LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_init
void *ht_init(int max_cnt)
{
    ht_t *p = NULL;
    int len = max_cnt * sizeof(ht_item_t);

    if (max_cnt <= 0) {
        return NULL;
    }

    p = malloc(sizeof(ht_t));
    if (NULL == p) {
        return NULL;
    }
    memset(p, 0, sizeof(ht_t));

    p->item = malloc(len);
    if (NULL == p->item) {
        free(p);
        return NULL;
    }
    memset(p->item, 0, len);
    pthread_mutex_init(&p->locker , NULL);

    p->cnt = max_cnt;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x4451
movq $0x0, -0x8(%rbp)
jmp 0x44e9
movl $0x38, %edi
callq 0x2140
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x4471
movq $0x0, -0x8(%rbp)
jmp 0x44e9
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2090
movslq -0x1c(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
jne 0x44b4
movq -0x18(%rbp), %rdi
callq 0x2240
movq $0x0, -0x8(%rbp)
jmp 0x44e9
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x2090
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21c0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_find_lockless
void *ht_find_lockless(void *ht, const void *key, unsigned int key_len, void *val, int *size_val)
{
    ht_item_t *p = _ht_find_lockless(ht, key, key_len);
    void *ret = NULL;

    while (p) {
        if (p->key && !memcmp(p->key, key, key_len)) {
            ret = p->val;
            break;
        }
        p = p->next;
    }

    if (ret && val && size_val) {
        memcpy(val, ret, p->size_val > *size_val ? *size_val : p->size_val);
        *size_val = p->size_val;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4660
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x45de
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x45d0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2490
cmpl $0x0, %eax
jne 0x45d0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x45de
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4597
cmpq $0x0, -0x38(%rbp)
je 0x4647
cmpq $0x0, -0x20(%rbp)
je 0x4647
cmpq $0x0, -0x28(%rbp)
je 0x4647
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x461d
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x4627
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %eax
movslq %eax, %rdx
callq 0x2570
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_find_lockless
static ht_item_t *_ht_find_lockless(void *ht, const void *key, unsigned int key_len)
{
    unsigned int pos = 0;
    ht_t *pt = (ht_t *)ht;

    if (!ht || !key || key_len <= 0) {
        return NULL;
    }

    pos = _hash_func((const unsigned char *)key, key_len) % pt->cnt;

    return (pt->item + pos);//users should check the pointer to get all the values.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4696
cmpq $0x0, -0x18(%rbp)
je 0x4696
cmpl $0x0, -0x1c(%rbp)
ja 0x46a0
movq $0x0, -0x8(%rbp)
jmp 0x46cd
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x4ec0
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_find
void *ht_find(void *ht, const void *key, unsigned int key_len, void *val, int *size_val)
{
    void *ret = NULL;

    ht_lock(ht);
    ret = ht_find_lockless(ht, key, key_len, val, size_val);
    ht_unlock(ht);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x4560
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4530
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_add
int ht_add(void *ht, const void *key, unsigned int len_key, const void *val, unsigned int size_val)
{
    int ret = 0;
    ht_lock(ht);
    ret = ht_add_lockless(ht, key, len_key, val, size_val);
    ht_unlock(ht);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x4740
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4530
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_del_node
static int _ht_del_node(void *ht_item, const void *key, unsigned int len_key)
{
    ht_item_t *p_tmp = NULL;
    ht_item_t *next = NULL;
    ht_item_t *parent = NULL; // the root node or previous node
    int flag = 0;
    int ret = -1;

    if (!ht_item) {
        return ret;
    }

    parent = (ht_item_t *)ht_item;
    while (parent) {
        if (parent->key && parent->val &&
                (!key || !memcmp(parent->key, key, len_key))) {
            next = parent->next;//store its next item befroe free.

            free(parent->key);
            parent->key = NULL;
            free(parent->val);
            parent->val = NULL;
            ret = 0;
            if (1 == flag) {//just free the added item not the root item.
                free(parent);
                p_tmp->next = next;
            } else {
                p_tmp = parent;
            }

            if (key) {
                break;
            }
            parent = next;
        } else {
            p_tmp = parent;
            parent = parent->next;
        }
        flag = 1;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
jne 0x4b2b
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4c21
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4c1b
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4bfb
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4bfb
cmpq $0x0, -0x18(%rbp)
je 0x4b7c
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x2490
cmpl $0x0, %eax
jne 0x4bfb
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x2240
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x40(%rbp)
movl $0x1, %eax
cmpl -0x3c(%rbp), %eax
jne 0x4be0
movq -0x38(%rbp), %rdi
callq 0x2240
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4be8
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4bf1
jmp 0x4c1b
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4c0f
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x4b33
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_del
int ht_del(void *ht, const void *key, unsigned int len_key)
{
    int ret = 0;
    ht_lock(ht);
    ret = ht_del_lockless(ht, key, len_key);
    ht_unlock(ht);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4aa0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4530
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_iterator_lockless
void *ht_iterator_lockless(void *ht, iter_func func, void *usr)
{
    int i = 0;
    ht_t *pt = ht;
    ht_item_t *item = NULL;

    if (!pt || !func) {
        return NULL;
    }

    for (i = 0; i < pt->cnt; i++) {
        item = pt->item + i;

        while (item) {
            if (!item->key || !item->val) {
                item = item->next;
            } else {
                if(0 == func(item->key, item->val, usr))
                    return item->key;
                else
                    item = item->next;
            }
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4cb9
cmpq $0x0, -0x18(%rbp)
jne 0x4cc6
movq $0x0, -0x8(%rbp)
jmp 0x4d73
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4d6b
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4d5b
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4d0f
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4d1d
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4d59
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdi
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4d4b
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d73
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4d59
jmp 0x4cf3
jmp 0x4d5d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4ccd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_clear_lockless
int ht_clear_lockless(void *ht)
{
    ht_t *pt = ht;
    int i = 0;
    if (!ht) {
        return -1;
    }

    for (i = 0; i < pt->cnt; i++) {
        _ht_del_node(pt->item + i, NULL, 0);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4dab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ded
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4de6
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4ae0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4db2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_clear
int ht_clear(void *ht)
{
    int ret = 0;
    ht_lock(ht);
    ret = ht_clear_lockless(ht);
    ht_unlock(ht);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
callq 0x4d80
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4530
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: ht_destroy
int ht_destroy(void *ht)
{
    ht_t *pt = (ht_t *)ht;
    if (!pt) {
        return -1;
    }

    ht_lock(pt);

    ht_clear_lockless(pt);
    free(pt->item);

    ht_unlock(pt);

    pthread_mutex_destroy(&pt->locker);
    free(pt);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4e64
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ea9
movq -0x18(%rbp), %rdi
callq 0x4500
movq -0x18(%rbp), %rdi
callq 0x4d80
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2240
movq -0x18(%rbp), %rdi
callq 0x4530
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2530
movq -0x18(%rbp), %rdi
callq 0x2240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/hash_table/hash_table.c
// Function: hash_func
static unsigned int _hash_func(const unsigned char *key, unsigned int length)
{
    unsigned int i = 0;
    unsigned int hash = 0;
    while (i != length) {
        hash += key[i++];
        hash += hash << 10;
        hash ^= hash >> 6;
    }
    hash += hash << 3;
    hash ^= hash >> 11;
    hash += hash << 15;
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x4f16
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0xa, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4ed9
movl -0x14(%rbp), %eax
shll $0x3, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0xb, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0xf, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/log/simple_log.c
// Function: set_log_level
void set_log_level(int lvl)
{
    if(lvl < LOG_LEVEL_DEBUG || lvl > LOG_LEVEL_NONE)
        g_log_lvl = LOG_LEVEL_ERR; 
    else 
        g_log_lvl = lvl;
    printf("set log level :  %d\n", lvl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x4f57
cmpl $0x4, -0x4(%rbp)
jle 0x4f63
movl $0x3, 0xa41f(%rip)      # 0xf380
jmp 0x4f6c
movl -0x4(%rbp), %eax
movl %eax, 0xa414(%rip)      # 0xf380
movl -0x4(%rbp), %esi
leaq 0x64a9(%rip), %rdi      # 0xb41f
movb $0x0, %al
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/log/simple_log.c
// Function: log_print
void log_print(LOG_LEVEL lvl, cchar *color, cchar *f, int l, cchar *fmt, ...)
{
    if(lvl < g_log_lvl)
        return;

    va_list ap;
    va_start(ap, fmt);

    char *tmp = NULL;
    char buf_date[20] = {0};
    time_t cur_time = time(NULL);

    f = !f ? "\b" : f;

    tmp = strrchr(f, '/');
    if(tmp)
        f = tmp + 1;

    //add color support
    if (color) 
        printf("%s", color);
    
    printf(LOG_FMT,get_timestamp(buf_date, 20, cur_time), g_log_desc[lvl], f, l);

    vprintf(fmt, ap);

    if (color) 
        printf("%s\n", COL_DEF);

    va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x4fd4
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xa38a(%rip), %eax      # 0xf380
jae 0x4ffd
jmp 0x5119
leaq -0x40(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq $0x0, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x2090
xorl %eax, %eax
movl %eax, %edi
callq 0x25b0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x505d
leaq 0x63e0(%rip), %rax      # 0xb434
movq %rax, -0x128(%rbp)
jmp 0x5068
movq -0x18(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x22e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x5098
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x50b1
movq -0x10(%rbp), %rsi
leaq 0x6d35(%rip), %rdi      # 0xbddf
movb $0x0, %al
callq 0x2080
leaq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
movl $0x14, %esi
callq 0x5130
movq %rax, %rsi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xa23e(%rip), %rax      # 0xf310
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
leaq 0x6351(%rip), %rdi      # 0xb436
movb $0x0, %al
callq 0x2080
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2340
cmpq $0x0, -0x10(%rbp)
je 0x5115
leaq 0x6cb3(%rip), %rdi      # 0xbdba
leaq 0x6338(%rip), %rsi      # 0xb446
movb $0x0, %al
callq 0x2080
leaq -0x40(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/log/simple_log.c
// Function: get_timestamp
static char *get_timestamp(char *buf, int len, time_t cur_time)
{
    struct tm tm_time;

    localtime_r(&cur_time, &tm_time);

    snprintf(buf, len, "%d-%d-%d %d:%d:%d",
             1900 + tm_time.tm_year, 1 + tm_time.tm_mon,
             tm_time.tm_mday, tm_time.tm_hour,
             tm_time.tm_min, tm_time.tm_sec);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x24c0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movl -0x3c(%rbp), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl -0x40(%rbp), %r8d
addl $0x1, %r8d
movl -0x44(%rbp), %r9d
movl -0x48(%rbp), %r11d
movl -0x4c(%rbp), %r10d
movl -0x50(%rbp), %eax
leaq 0x62cc(%rip), %rdx      # 0xb44b
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/sha256/sha256.c
// Function: sha256_init
void
sha256_init(sha256_t *p)
{
  p->state[0] = 0x6a09e667;
  p->state[1] = 0xbb67ae85;
  p->state[2] = 0x3c6ef372;
  p->state[3] = 0xa54ff53a;
  p->state[4] = 0x510e527f;
  p->state[5] = 0x9b05688c;
  p->state[6] = 0x1f83d9ab;
  p->state[7] = 0x5be0cd19;
  p->count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6a09e667, (%rax)     # imm = 0x6A09E667
movq -0x8(%rbp), %rax
movl $0xbb67ae85, 0x4(%rax)  # imm = 0xBB67AE85
movq -0x8(%rbp), %rax
movl $0x3c6ef372, 0x8(%rax)  # imm = 0x3C6EF372
movq -0x8(%rbp), %rax
movl $0xa54ff53a, 0xc(%rax)  # imm = 0xA54FF53A
movq -0x8(%rbp), %rax
movl $0x510e527f, 0x10(%rax) # imm = 0x510E527F
movq -0x8(%rbp), %rax
movl $0x9b05688c, 0x14(%rax) # imm = 0x9B05688C
movq -0x8(%rbp), %rax
movl $0x1f83d9ab, 0x18(%rax) # imm = 0x1F83D9AB
movq -0x8(%rbp), %rax
movl $0x5be0cd19, 0x1c(%rax) # imm = 0x5BE0CD19
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/sha256/sha256.c
// Function: sha256_update
void
sha256_update(sha256_t *p, const unsigned char *data, size_t size)
{
  uint32_t curBufferPos = (uint32_t)p->count & 0x3F;
  while (size > 0)
  {
    p->buffer[curBufferPos++] = *data++;
    p->count++;
    size--;
    if (curBufferPos == 64)
    {
      curBufferPos = 0;
      sha256_write_byte_block(p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x5663
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, 0x28(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpl $0x40, -0x1c(%rbp)
jne 0x5661
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57f0
jmp 0x5602
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/sha256/sha256.c
// Function: sha256_final
void
sha256_final(sha256_t *p, unsigned char *digest)
{
  uint64_t lenInBits = (p->count << 3);
  uint32_t curBufferPos = (uint32_t)p->count & 0x3F;
  unsigned i;
  p->buffer[curBufferPos++] = 0x80;
  while (curBufferPos != (64 - 8))
  {
    curBufferPos &= 0x3F;
    if (curBufferPos == 0)
      sha256_write_byte_block(p);
    p->buffer[curBufferPos++] = 0;
  }
  for (i = 0; i < 8; i++)
  {
    p->buffer[curBufferPos++] = (unsigned char)(lenInBits >> 56);
    lenInBits <<= 8;
  }
  sha256_write_byte_block(p);

  for (i = 0; i < 8; i++)
  {
    *digest++ = (unsigned char)(p->state[i] >> 24);
    *digest++ = (unsigned char)(p->state[i] >> 16);
    *digest++ = (unsigned char)(p->state[i] >> 8);
    *digest++ = (unsigned char)(p->state[i]);
  }
  sha256_init(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movb $-0x80, 0x28(%rax,%rcx)
cmpl $0x38, -0x1c(%rbp)
je 0x56ea
movl -0x1c(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x56d2
movq -0x8(%rbp), %rdi
callq 0x57f0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movb $0x0, 0x28(%rax,%rcx)
jmp 0x56b4
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jae 0x572d
movq -0x18(%rbp), %rax
shrq $0x38, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, 0x28(%rax,%rcx)
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x56f1
movq -0x8(%rbp), %rdi
callq 0x57f0
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jae 0x57d2
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x573d
movq -0x8(%rbp), %rdi
callq 0x5520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/sha256/sha256.c
// Function: sha256_write_byte_block
static void
sha256_write_byte_block(sha256_t *p)
{
  uint32_t data32[16];
  unsigned i;
  for (i = 0; i < 16; i++)
    data32[i] =
      ((uint32_t)(p->buffer[i * 4    ]) << 24) +
      ((uint32_t)(p->buffer[i * 4 + 1]) << 16) +
      ((uint32_t)(p->buffer[i * 4 + 2]) <<  8) +
      ((uint32_t)(p->buffer[i * 4 + 3]));
  sha256_transform(p->state, data32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x54(%rbp)
cmpl $0x10, -0x54(%rbp)
jae 0x5877
movq -0x8(%rbp), %rax
movl -0x54(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
movzbl 0x28(%rax,%rcx), %ecx
shll $0x18, %ecx
movq -0x8(%rbp), %rax
movl -0x54(%rbp), %edx
shll $0x2, %edx
addl $0x1, %edx
movl %edx, %edx
movzbl 0x28(%rax,%rdx), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl -0x54(%rbp), %edx
shll $0x2, %edx
addl $0x2, %edx
movl %edx, %edx
movzbl 0x28(%rax,%rdx), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl -0x54(%rbp), %edx
shll $0x2, %edx
addl $0x3, %edx
movl %edx, %edx
movzbl 0x28(%rax,%rdx), %eax
addl %eax, %ecx
movl -0x54(%rbp), %eax
movl %ecx, -0x50(%rbp,%rax,4)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5803
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5890
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: timeval_substract
int _timeval_substract (struct timeval * a,
                           struct timeval * b,
                           struct timeval * result)
{
    /* Perform the carry for the later subtraction by updating
     * y. */
    if (a->tv_usec < b->tv_usec) {
        int nsec = (b->tv_usec - a->tv_usec) / 1000000 + 1;
        b->tv_usec -= 1000000 * nsec;
        b->tv_sec += nsec;
    }

    if (a->tv_usec - b->tv_usec > 1000000) {
        int nsec = (a->tv_usec - b->tv_usec) / 1000000;
        b->tv_usec += 1000000 * nsec;
        b->tv_sec -= nsec;
    }

    /* get the result */
    result->tv_sec = a->tv_sec - b->tv_sec;
    result->tv_usec = a->tv_usec - b->tv_usec;

       /* return 1 if result is negative. */
       return a->tv_sec < b->tv_sec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x6f0a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
imull $0xf4240, -0x1c(%rbp), %eax # imm = 0xF4240
movslq %eax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movslq -0x1c(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jle 0x6f66
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movl %eax, -0x20(%rbp)
imull $0xf4240, -0x20(%rbp), %eax # imm = 0xF4240
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movslq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
subq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: add_select_array
static inline void _add_select_array(int cloudfd, int *localfd_array, int len, fd_set *rfds)
{
    int i = 0;

    FD_ZERO(rfds);
    if (cloudfd >= 0) {
        FD_SET(cloudfd, rfds);
    }
    for(i = 0; i < len; i++){
        if(localfd_array[i] >= 0)
            FD_SET(localfd_array[i], rfds);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq $0x10, %rax
jae 0x819b
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8178
jmp 0x819d
cmpl $0x0, -0x4(%rbp)
jl 0x81e6
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x40(%rbp), %rdx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8263
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x8256
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x50(%rbp), %rdx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x8258
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x81ed
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: get_max_socketfd
static inline int _get_max_socketfd(int cloudfd, int *localfd_array, int len)
{
    int i = 0;
    int max = 0;

    for(i = 0; i < len; i++){
        if(localfd_array[i] > max){
            max = localfd_array[i];
        }
    }

    return 1 + MAX_VAL(cloudfd, max); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x82c6
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jle 0x82b9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x82bb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8293
movl -0x4(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x82d6
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x82dc
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: send_error_resp
static void _send_error_resp(int code, char *msg, char *msg_id, char *session_id, char *send_buf)
{
    char *tmp_buf = NULL;
    char *buf_hdr = NULL;

    tmp_buf  = sda_gen_payload_msg(code, NULL, msg);
    buf_hdr = sda_gen_msg_header(MSG_RESP_OK , strlen(tmp_buf), msg_id, session_id);
    
    memset(send_buf, 0, DEFAULT_MSG_BUFFER_LEN);
    snprintf(send_buf, DEFAULT_MSG_BUFFER_LEN, "%s%s", buf_hdr, tmp_buf); 
    rd_net_write(&g_network, NULL, send_buf, strlen(send_buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x91f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2260
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %edi, %edi
callq 0x9100
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2090
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x2000, %esi           # imm = 0x2000
leaq 0x3579(%rip), %rdx      # 0xb8ee
movb $0x0, %al
callq 0x20b0
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2260
movq -0x40(%rbp), %rdx
movl %eax, %ecx
leaq 0x6fee(%rip), %rdi      # 0xf388
xorl %eax, %eax
movl %eax, %esi
xorl %r8d, %r8d
callq 0x27a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: get_active_socketfd_index
static inline int _get_active_socketfd_index(int *localfd_array, int len, fd_set *rfds)
{
    int i = 0;

    for(i = 0; i < len; i++){
        if(localfd_array[i] == -1)
            continue;
        if(FD_ISSET(localfd_array[i], rfds) > 0)
            return i;
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8465
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x83e9
jmp 0x8457
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jle 0x8455
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x846c
jmp 0x8457
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x83cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: sda_connect_to_local_service
static int sda_connect_to_local_service (void)
{
    int ret = 0;
    int socketfd = -1;

    struct sockaddr_in server_sshd;

    memset(&server_sshd, 0, sizeof(struct sockaddr_in));
    server_sshd.sin_family = PF_INET;
    server_sshd.sin_port = htons(g_cfg->listen_port);
    server_sshd.sin_addr.s_addr = inet_addr(g_cfg->listen_ip);

    socketfd = socket(PF_INET, SOCK_STREAM, 0);
    if (-1 == socketfd) {
        log_error("create socket failed, %s ", strerror(errno));
        return -1;
    }

    ret = connect(socketfd, (struct sockaddr *)&server_sshd, sizeof(server_sshd));
    if (-1 == ret) {
        log_error("connect to failed, %s ", strerror(errno));
        close(socketfd);
        return -1;
    }
    log_info("connect to local service succeed, socketfd: %d. ", socketfd);
    return socketfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2090
movw $0x2, -0x1c(%rbp)
movq 0x6a15(%rip), %rax      # 0xf3c8
movl 0x38(%rax), %eax
movzwl %ax, %edi
callq 0x20e0
movw %ax, -0x1a(%rbp)
movq 0x69ff(%rip), %rax      # 0xf3c8
movq 0x30(%rax), %rdi
callq 0x25e0
movl %eax, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x23b0
movl %eax, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x8a34
callq 0x23e0
movl (%rax), %edi
callq 0x2320
movq %rax, %r9
movl $0x3, %edi
leaq 0x2bd2(%rip), %rsi      # 0xb5e0
leaq 0x2bd1(%rip), %rdx      # 0xb5e6
movl $0x57, %ecx
leaq 0x31ec(%rip), %r8       # 0xbc0d
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8ac8
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x10, %edx
callq 0x2380
movl %eax, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x8a98
callq 0x23e0
movl (%rax), %edi
callq 0x2320
movq %rax, %r9
movl $0x3, %edi
leaq 0x2b73(%rip), %rsi      # 0xb5e0
leaq 0x2b72(%rip), %rdx      # 0xb5e6
movl $0x5d, %ecx
leaq 0x31a7(%rip), %r8       # 0xbc27
movb $0x0, %al
callq 0x4f90
movl -0xc(%rbp), %edi
callq 0x20c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8ac8
movl -0xc(%rbp), %r9d
movl $0x1, %edi
leaq 0x2b91(%rip), %rsi      # 0xb639
leaq 0x2b37(%rip), %rdx      # 0xb5e6
movl $0x61, %ecx
leaq 0x3183(%rip), %r8       # 0xbc3e
movb $0x0, %al
callq 0x4f90
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: add_localfd
static inline int _add_localfd(int localfd, int *localfd_array, int len)
{
    int i = 0;

    for(i = 0; i < len; i++){
        if(localfd_array[i] == -1){
            localfd_array[i] = localfd;
            log_info("index: %d, localfd: %d\n", i, localfd);
            break; 
        }
    }

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8b63
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x8b56
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %r9d
movl -0x4(%rbp), %eax
movl $0x1, %edi
leaq 0x2b02(%rip), %rsi      # 0xb639
leaq 0x2aa8(%rip), %rdx      # 0xb5e6
movl $0xc9, %ecx
leaq 0x3125(%rip), %r8       # 0xbc6f
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4f90
jmp 0x8b63
jmp 0x8b58
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8b00
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: del_socketfd_by_id
static inline void _del_socketfd_by_id(int fd, int *localfd_array, int len)
{
    int i = 0;
    
    for(i = 0; i < len; i++){
        if (fd == localfd_array[i]) {
            localfd_array[i] = -1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8bc0
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x8bb3
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x8bb5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8b8c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: is_login_ok
static int is_login_ok(char *buf, int buf_len)
{
    char *ret = NULL;
    int len = 0, type = 0;
    
    ret = json_get_value_by_name(buf, buf_len, "code", &len, &type);
    if(ret == NULL || len <= 0 || type != JNUMBER || atoi(ret) != 0){
   		log_error("cloud response error: %s ", buf);
		return 0; 
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x3084(%rip), %rdx      # 0xbc87
leaq -0x24(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x3f50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8c35
cmpl $0x0, -0x24(%rbp)
jle 0x8c35
cmpl $0x3, -0x28(%rbp)
jne 0x8c35
movq -0x20(%rbp), %rdi
callq 0x2360
cmpl $0x0, %eax
je 0x8c68
movq -0x10(%rbp), %r9
movl $0x3, %edi
leaq 0x299b(%rip), %rsi      # 0xb5e0
leaq 0x299a(%rip), %rdx      # 0xb5e6
movl $0xad, %ecx
leaq 0x3034(%rip), %r8       # 0xbc8c
movb $0x0, %al
callq 0x4f90
movl $0x0, -0x4(%rbp)
jmp 0x8c6f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: close_all_conn
static inline void _close_all_conn(int *localfd_array, int len)
{
    int i = 0;

    for(i = 0; i < len; i++){
        if(localfd_array[i] > 0){
            close(localfd_array[i]);
            localfd_array[i] = -1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8cdf
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x8cd2
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x20c0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x8cd4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8c9d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: sig_int_handler
static void _sig_int_handler(int sig)
{
    if (SIGINT == sig) {
        if(g_is_running == 0){
            log_info("force exit !\r\n");
            exit(0); 
        }
        g_is_running = 0; 
        log_info( "Caught signal: %s, exiting..., %d\r\n", strsignal(sig), sig);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x2, %eax
cmpl -0x4(%rbp), %eax
jne 0x8f9c
cmpl $0x0, 0x640c(%rip)      # 0xf338
jne 0x8f5b
movl $0x1, %edi
leaq 0x26ff(%rip), %rsi      # 0xb639
leaq 0x26a5(%rip), %rdx      # 0xb5e6
movl $0x1d, %ecx
leaq 0x2d59(%rip), %r8       # 0xbca6
movb $0x0, %al
callq 0x4f90
xorl %edi, %edi
callq 0x2100
movl $0x0, 0x63d3(%rip)      # 0xf338
movl -0x4(%rbp), %edi
callq 0x2120
movq %rax, %r9
movl -0x4(%rbp), %eax
movl $0x1, %edi
leaq 0x26ba(%rip), %rsi      # 0xb639
leaq 0x2660(%rip), %rdx      # 0xb5e6
movl $0x21, %ecx
leaq 0x2d23(%rip), %r8       # 0xbcb5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4f90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: clear_arguments
static void _clear_arguments(int argc, char **argv)
{
    int i = 1;
    for (i = 1; i < argc; i++){
        int j = strlen(argv[i]);  
        for (j = j - 1; j >= 0; j--){
            argv[i][j] = ' ';
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x9024
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x9017
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8ff2
jmp 0x9019
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8fcd
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/remote_terminal.c
// Function: singleton
static void _singleton()
{
    char cmd[512] = {0};
    log_debug( "current pid:  %d ",getpid());
    
    snprintf(cmd, sizeof(cmd), "kill -2 `cat /tmp/remote_terminal.pid` 2> /dev/null");  
    system(cmd); 

    memset(cmd, 0, sizeof(cmd));
    snprintf(cmd, sizeof(cmd), "echo \"%d\" > /tmp/remote_terminal.pid", getpid());
    system(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
leaq -0x200(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2090
callq 0x21b0
movl %eax, %r9d
xorl %edi, %edi
leaq 0x1fa5(%rip), %rsi      # 0xb004
leaq 0x2580(%rip), %rdx      # 0xb5e6
movl $0x248, %ecx            # imm = 0x248
leaq 0x2c67(%rip), %r8       # 0xbcd9
movb $0x0, %al
callq 0x4f90
leaq -0x200(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
leaq 0x2c5f(%rip), %rdx      # 0xbceb
movb $0x0, %al
callq 0x20b0
leaq -0x200(%rbp), %rdi
callq 0x2170
leaq -0x200(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2090
leaq -0x200(%rbp), %rax
movq %rax, -0x208(%rbp)
callq 0x21b0
movq -0x208(%rbp), %rdi
movl %eax, %ecx
movl $0x200, %esi            # imm = 0x200
leaq 0x2c45(%rip), %rdx      # 0xbd1f
movb $0x0, %al
callq 0x20b0
leaq -0x200(%rbp), %rdi
callq 0x2170
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/core/net_protocol.c
// Function: sda_gen_msg_header
char *sda_gen_msg_header(int msg_type, int payload_len, char *msg_id, char *token)
{
    static char msg[DEFAULT_MSG_HDR_LEN] = {0};

    memset(msg, 0, sizeof(msg));
    snprintf(msg, sizeof(msg) - 1, MSG_HEAD_FMT,
                    msg_type, payload_len, msg_id == NULL ? rand_string_static() : msg_id,
                    time(NULL), token == NULL ? "" : token);

    log_debug("send msg : %s\n", msg);
    return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq 0x62b3(%rip), %rdi      # 0xf3d0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2090
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9149
movb $0x0, %al
callq 0x43f0
movq %rax, -0x28(%rbp)
jmp 0x9151
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x25b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x917a
leaq 0x22c1(%rip), %rax      # 0xb435
movq %rax, -0x40(%rbp)
jmp 0x9182
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %r10
movq -0x38(%rbp), %r9
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %ecx
movq -0x40(%rbp), %rax
leaq 0x6234(%rip), %rdi      # 0xf3d0
movl $0x3ff, %esi            # imm = 0x3FF
leaq 0x2b9c(%rip), %rdx      # 0xbd44
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x20b0
xorl %edi, %edi
leaq 0x1e43(%rip), %rsi      # 0xb004
leaq 0x2bcf(%rip), %rdx      # 0xbd97
movl $0x11, %ecx
leaq 0x2bdb(%rip), %r8       # 0xbdaf
leaq 0x61f5(%rip), %r9       # 0xf3d0
movb $0x0, %al
callq 0x4f90
leaq 0x61e7(%rip), %rax      # 0xf3d0
addq $0x50, %rsp
popq %rbp
retq
nop