LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_rbtree.c
// Function: qq_rbtree_left_rotate
static inline void
qq_rbtree_left_rotate(qq_rbtree_node_t **root, qq_rbtree_node_t *sentinel,
    qq_rbtree_node_t *node)
{
    qq_rbtree_node_t  *temp;

    temp = node->right;
    node->right = temp->left;

    if (temp->left != sentinel) {
        temp->left->parent = node;
    }

    temp->parent = node->parent;

    if (node == *root) {
        *root = temp;
    } else if (node == node->parent->left) {
        node->parent->left = temp;
    } else {
        node->parent->right = temp;
    }

    temp->left = node;
    node->parent = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xc1ca
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xc1f4
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc22a
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc218
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xc228
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xc22a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_rbtree.c
// Function: qq_rbtree_right_rotate
static inline void
qq_rbtree_right_rotate(qq_rbtree_node_t **root, qq_rbtree_node_t *sentinel,
    qq_rbtree_node_t *node)
{
    qq_rbtree_node_t  *temp;

    temp = node->left;
    node->left = temp->right;

    if (temp->right != sentinel) {
        temp->right->parent = node;
    }

    temp->parent = node->parent;

    if (node == *root) {
        *root = temp;
    } else if (node == node->parent->right) {
        node->parent->right = temp;
    } else {
        node->parent->left = temp;
    }

    temp->right = node;
    node->parent = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xc29a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xc2c4
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc2fa
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0xc2e8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xc2f8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xc2fa
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_rbtree.c
// Function: qq_rbtree_insert_value
void
qq_rbtree_insert_value(qq_rbtree_node_t *temp, qq_rbtree_node_t *node,
    qq_rbtree_node_t *sentinel)
{
    qq_rbtree_node_t  **p;

    for ( ;; ) {
        p = (node->key < temp->key) ? &temp->left : &temp->right;

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    qq_rbt_red(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xc34e
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0xc35a
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xc371
jmp 0xc37e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc330
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_rbtree.c
// Function: qq_rbtree_insert_timer_value
void
qq_rbtree_insert_timer_value(qq_rbtree_node_t *temp, qq_rbtree_node_t *node,
    qq_rbtree_node_t *sentinel)
{
    qq_rbtree_node_t  **p;

    for ( ;; ) {
        /*
         * Timer values
         * 1) are spread in small range, usually several minutes,
         * 2) and overflow each 49 days, if milliseconds are stored in 32 bits.
         * The comparison takes into account that overflow.
         */

        /*  node->key < temp->key */

        p = ((qq_rbtree_key_int_t) (node->key - temp->key) < 0)
            ? &temp->left : &temp->right;

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    qq_rbt_red(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
cmpq $0x0, %rax
jge 0xc3f2
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0xc3fe
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xc415
jmp 0xc422
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc3d0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_rbtree.c
// Function: qq_rbtree_next
qq_rbtree_node_t *
qq_rbtree_next(qq_rbtree_t *tree, qq_rbtree_node_t *node)
{
    qq_rbtree_node_t  *root, *sentinel, *parent;

    sentinel = tree->sentinel;

    if (node->right != sentinel) {
        return qq_rbtree_min(node->right, sentinel);
    }

    root = tree->root;

    for ( ;; ) {
        parent = node->parent;

        if (node == root) {
            return NULL;
        }

        if (node == parent->left) {
            return parent;
        }

        node = parent;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0xc9f1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xc980
movq %rax, -0x8(%rbp)
jmp 0xca3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xca1c
movq $0x0, -0x8(%rbp)
jmp 0xca3e
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xca34
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xca3e
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc9fc
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_string.c
// Function: qq_strnlen
size_t
qq_strnlen(u_char *p, size_t n)
{
    size_t  i;

    for (i = 0; i < n; i++) {
        if (p[i] == '\0') {
            return i;
        }
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xcb19
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xcb09
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb21
jmp 0xcb0b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcae4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_string.c
// Function: qq_cpystrn
u_char *
qq_cpystrn(u_char *dst, u_char *src, size_t n)
{
    if (n == 0) {
        return dst;
    }

    while (--n) {
        *dst = *src;

        if (*dst == '\0') {
            return dst;
        }

        dst++;
        src++;
    }

    *dst = '\0';

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcb51
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcbb0
jmp 0xcb53
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xcba1
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xcb87
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcbb0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xcb53
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_string.c
// Function: qq_hex_dump
u_char *
qq_hex_dump(u_char *dst, u_char *src, size_t len)
{
    static u_char  hex[] = "0123456789abcdef";

    while (len--) {
        *dst++ = hex[*src >> 4];
        *dst++ = hex[*src++ & 0xf];
    }

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0xcc42
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x76a7(%rip), %rax      # 0x142a0
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x7674(%rip), %rax      # 0x142a0
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0xcbd0
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_string.c
// Function: qq_str_rbtree_insert_value
void
qq_str_rbtree_insert_value(qq_rbtree_node_t *temp,
    qq_rbtree_node_t *node, qq_rbtree_node_t *sentinel)
{
    qq_str_rbtree_node_t   *n, *t;
    qq_rbtree_node_t      **p;

    for ( ;; ) {
        n = (qq_str_rbtree_node_t *) node;
        t = (qq_str_rbtree_node_t *) temp;

        if (node->key != temp->key) {
            p = (node->key < temp->key) ? &temp->left : &temp->right;
        } else if (n->str.len != t->str.len) {
            p = (n->str.len < t->str.len) ? &temp->left : &temp->right;
        } else {
            p = (memcmp(n->str.data, t->str.data, n->str.len) < 0)
                 ? &temp->left : &temp->right;
        }

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    qq_rbt_red(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0xce7b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xce62
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0xce6e
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xcf09
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x28(%rcx), %rax
je 0xcec3
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xcead
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0xceb9
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xcf07
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x20f0
cmpl $0x0, %eax
jge 0xcef3
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0xceff
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xcf09
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xcf18
jmp 0xcf28
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xce24
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_string.c
// Function: qq_str_rbtree_lookup
qq_str_rbtree_node_t *
qq_str_rbtree_lookup(qq_rbtree_t *rbtree, qq_str_t *val, uint32_t hash)
{
    qq_int_t               rc;
    qq_str_rbtree_node_t  *n;
    qq_rbtree_node_t      *node, *sentinel;

    node = rbtree->root;
    sentinel = rbtree->sentinel;

    while (node != sentinel) {
        n = (qq_str_rbtree_node_t *) node;

        if (hash != node->key) {
            node = (hash < node->key) ? node->left : node->right;
            continue;
        }

        if (val->len != n->str.len) {
            node = (val->len < n->str.len) ? node->left : node->right;
            continue;
        }

        rc = memcmp(val->data, n->str.data, val->len);
        if (rc < 0) {
            node = node->left;
            continue;
        }

        if (rc > 0) {
            node = node->right;
            continue;
        }

        return n;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0xd091
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
je 0xcfec
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xcfd6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xcfe2
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xcf9a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x28(%rcx), %rax
je 0xd035
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xd01c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xd028
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xcf9a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x20f0
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xd06f
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xcf9a
cmpq $0x0, -0x28(%rbp)
jle 0xd087
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xcf9a
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd099
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_tcp_send.c
// Function: qq_tcp_send
ssize_t
qq_tcp_send(qq_connection_t *c, u_char *buf, size_t size)
{
    ssize_t       n;
    qq_err_t      err;
    qq_event_t   *wev;

    wev = c->write;

    for ( ;; ) {
        n = send(c->fd, buf, size, 0);

        qq_log_debug("send: fd:%d n:%d of size:%d", c->fd, n, size);

        if (n > 0) {
            if (n < (ssize_t) size) {
                wev->ready = 0;
            }
            return n;
        }

        err = errno;
        if (n == 0) {
            qq_log_error(err, "send() returned zero");
            wev->ready = 0;
            return n;
        }

        if (err == QQ_EAGAIN || err == QQ_EINTR) {
            wev->ready = 0;

            qq_log_debug("send() not ready");

            if (err == QQ_EAGAIN) {
                return QQ_AGAIN;
            }
        } else {
            wev->error = 1;
            return QQ_ERROR;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2140
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2d71(%rip), %rdi      # 0x10051
movb $0x0, %al
callq 0x9e70
cmpq $0x0, -0x28(%rbp)
jle 0xd315
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0xd308
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd3b2
callq 0x2030
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd351
movl -0x2c(%rbp), %edi
leaq 0x2d3d(%rip), %rsi      # 0x1006d
movb $0x0, %al
callq 0x9cc0
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd3b2
cmpl $0xb, -0x2c(%rbp)
je 0xd35d
cmpl $0x4, -0x2c(%rbp)
jne 0xd38d
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
leaq 0x2d0e(%rip), %rdi      # 0x10082
movb $0x0, %al
callq 0x9e70
cmpl $0xb, -0x2c(%rbp)
jne 0xd38b
movq $-0x2, -0x8(%rbp)
jmp 0xd3b2
jmp 0xd3ad
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x8(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0xd3b2
jmp 0xd2b0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_time.c
// Function: qq_time_update
void
qq_time_update(void)
{
    u_char          *p;
    struct tm        t;
    time_t           sec;
    qq_uint_t        msec;
    struct timeval   tv;

    gettimeofday(&tv, NULL);

    sec = tv.tv_sec;
    msec = tv.tv_usec / 1000;

    qq_current_msec = (qq_msec_t) sec * 1000 + msec;
#if (QQ_HAVE_TIMESTAMP_JSON_PKG)
    sprintf(qq_timestamp_json_pkg, "{\"timestamp\":%lu}", qq_current_msec);
    qq_timestamp_json_pkg_size = strlen(qq_timestamp_json_pkg) + 1;
#endif


    qq_localtime(sec, &t);

    p = cached_err_log_time;
    (void) sprintf(p, "%4d/%02d/%02d_%02d:%02d:%02d",
                   t.tm_year, t.tm_mon,
                   t.tm_mday, t.tm_hour,
                   t.tm_min,  t.tm_sec);

    qq_cached_err_log_time.data = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22e0
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, -0x50(%rbp)
imulq $0x3e8, -0x48(%rbp), %rax # imm = 0x3E8
addq -0x50(%rbp), %rax
movq %rax, 0x72ce(%rip)      # 0x146f0
movq 0x72c7(%rip), %rdx      # 0x146f0
leaq 0x71b0(%rip), %rdi      # 0x145e0
leaq 0x2c5c(%rip), %rsi      # 0x10093
movb $0x0, %al
callq 0x2070
leaq 0x719b(%rip), %rdi      # 0x145e0
callq 0x20e0
addq $0x1, %rax
movq %rax, 0x72a3(%rip)      # 0x146f8
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd4b0
leaq 0x7297(%rip), %rax      # 0x14700
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
movl -0x38(%rbp), %r9d
movl -0x3c(%rbp), %r10d
movl -0x40(%rbp), %eax
leaq 0x2c18(%rip), %rsi      # 0x100a5
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
movq %rax, 0x7241(%rip)      # 0x146e8
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_time.c
// Function: qq_localtime
void
qq_localtime(time_t s, struct tm *tp)
{
    struct tm  *t;

    t = localtime(&s);
    *tp = *t;

    tp->tm_mon++;
    tp->tm_year += 1900;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x38, %edx
callq 0x21e0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_udp_recv.c
// Function: qq_udp_recv
ssize_t
qq_udp_recv(qq_connection_t *c, u_char *buf, size_t size)
{
    ssize_t       n;
    qq_err_t      err;
    qq_event_t   *rev;

    rev = c->read;

    do {
        n = recv(c->fd, buf, size, 0);

        qq_log_debug("recv: fd:%d %d of %d", c->fd, n, size);

        if (n >= 0) {
            return n;
        }

        err = errno;

        if (err == QQ_EAGAIN || err == QQ_EINTR) {
            qq_log_debug("recv() not ready");
            n = QQ_AGAIN;
        } else {
            n = QQ_ERROR;
            break;
        }
    } while (err == QQ_EINTR);

    rev->ready = 0;

    if (n == QQ_ERROR) {
        rev->error = 1;
    }
	
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2b62(%rip), %rdi      # 0x100c2
movb $0x0, %al
callq 0x9e70
cmpq $0x0, -0x28(%rbp)
jl 0xd578
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd5f1
callq 0x2030
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xb, -0x2c(%rbp)
je 0xd58e
cmpl $0x4, -0x2c(%rbp)
jne 0xd5a6
leaq 0x2a9d(%rip), %rdi      # 0x10032
movb $0x0, %al
callq 0x9e70
movq $-0x2, -0x28(%rbp)
jmp 0xd5b0
movq $-0x1, -0x28(%rbp)
jmp 0xd5bc
jmp 0xd5b2
cmpl $0x4, -0x2c(%rbp)
je 0xd530
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
cmpq $-0x1, -0x28(%rbp)
jne 0xd5e9
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_udp_send.c
// Function: qq_udp_send
ssize_t
qq_udp_send(qq_connection_t *c, u_char *buf, size_t size)
{
    ssize_t       n;
    qq_err_t      err;
    qq_event_t   *wev;

    wev = c->write;

    for ( ;; ) {
        n = sendto(c->fd, buf, size, 0, c->sockaddr, c->socklen);

        qq_log_debug("sendto: fd:%d %d of %d to \"%s\"",
                     c->fd, n, size, c->addr_text);

        if (n >= 0) {
            if ((size_t) n != size) {
                wev->error = 1;
                return QQ_ERROR;
            }
            return n;
        }

        err = errno;

        if (err == QQ_EAGAIN) {
            wev->ready = 0;
            qq_log_debug("sendto() not ready");
            return QQ_AGAIN;
        }

        if (err != QQ_EINTR) {
            wev->error = 1;
            return QQ_ERROR;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %r9d
movq -0x40(%rbp), %r8
xorl %ecx, %ecx
callq 0x2050
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %r8
leaq 0x2a67(%rip), %rdi      # 0x100d7
movb $0x0, %al
callq 0x9e70
cmpq $0x0, -0x28(%rbp)
jl 0xd6b2
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xd6a8
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x8(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0xd715
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd715
callq 0x2030
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xb, -0x2c(%rbp)
jne 0xd6ea
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x21, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
leaq 0x2a1d(%rip), %rdi      # 0x100f6
movb $0x0, %al
callq 0x9e70
movq $-0x2, -0x8(%rbp)
jmp 0xd715
cmpl $0x4, -0x2c(%rbp)
je 0xd710
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x8(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0xd715
jmp 0xd620
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_video_audio_device.c
// Function: qq_video_audio_device_init
qq_int_t
qq_video_audio_device_init(qq_cycle_t *cycle)
{
    if (qq_add_listening_config(SOCK_DGRAM,
        QQ_VIDEO_AUDIO_DEVICE_UDP_LISTENING_PORT,
        QQ_VIDEO_AUDIO_DEVICE_UDP_LISTENING_POOL_SIZE,
        qq_video_audio_device_process_request_handler) == QQ_ERROR)
    {
        qq_log_error(0, "qq_video_audio_device_init()->qq_add_listening_config() failed");
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x2, %edi
movl $0x32c8, %esi           # imm = 0x32C8
movl $0x200, %edx            # imm = 0x200
leaq 0x3e(%rip), %rcx        # 0xd780
callq 0x90f0
cmpq $-0x1, %rax
jne 0xd767
xorl %edi, %edi
leaq 0x29b3(%rip), %rsi      # 0x10109
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xd76f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_init
qq_int_t
qq_wifi_device_init(qq_cycle_t *cycle)
{
    if (qq_add_listening_config(SOCK_STREAM,
        QQ_WIFI_DEVICE_TCP_LISTENING_PORT,
        QQ_WIFI_DEVICE_TCP_LISTENING_POOL_SIZE,
        qq_wifi_device_init_connection_handler) == QQ_ERROR)
    {
        qq_log_error(0, "qq_wifi_device_init()->qq_add_listening_config() failed");
        return QQ_ERROR;
    }

    qq_rbtree_init(&qq_wifi_device_rbtree, &qq_wifi_device_sentinel,
                    qq_wifi_device_rbtree_insert_value);

    qq_wifi_device_md5_id_str_pos = strlen(QQ_WIFI_DEVICE_MD5_CORE_STR);
    memcpy(qq_wifi_device_md5_str, QQ_WIFI_DEVICE_MD5_CORE_STR, strlen(QQ_WIFI_DEVICE_MD5_CORE_STR));

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x2ee0, %esi           # imm = 0x2EE0
movl $0x200, %edx            # imm = 0x200
leaq 0xae(%rip), %rcx        # 0xd8e0
callq 0x90f0
cmpq $-0x1, %rax
jne 0xd857
xorl %edi, %edi
leaq 0x297e(%rip), %rsi      # 0x101c4
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xd8cf
movb $0x0, 0x6ee2(%rip)      # 0x14740
leaq 0x6ebb(%rip), %rax      # 0x14720
movq %rax, 0x6edc(%rip)      # 0x14748
leaq 0x6ead(%rip), %rax      # 0x14720
movq %rax, 0x6ed6(%rip)      # 0x14750
leaq 0xcf(%rip), %rax        # 0xd950
movq %rax, 0x6ed0(%rip)      # 0x14758
movq $0x15, 0x6ecd(%rip) # 0x14760
movq 0x2962(%rip), %rax      # 0x101fc
movq %rax, 0x6ecf(%rip)      # 0x14770
movq 0x295c(%rip), %rax      # 0x10204
movq %rax, 0x6ec9(%rip)      # 0x14778
movl 0x2957(%rip), %eax      # 0x1020c
movl %eax, 0x6ec5(%rip)      # 0x14780
movb 0x294f(%rip), %al       # 0x10210
movb %al, 0x6ebd(%rip)       # 0x14784
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_init_connection_handler
static void
qq_wifi_device_init_connection_handler(qq_connection_t *c)
{
    qq_event_t   *rev, *wev;

    qq_log_debug("qq_wifi_device_init_connection_handler()");

    rev = c->read;
    rev->handler = qq_wifi_device_pretreatment_process_handler;

    wev = c->write;
    wev->handler = qq_wifi_device_write_event_handler;

    qq_event_add_timer(rev, QQ_WIFI_DEVICE_CONNECTION_TIMEOUT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2935(%rip), %rdi      # 0x10228
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x18f(%rip), %rcx       # 0xdaa0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3f4(%rip), %rcx       # 0xdd20
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0xbb8, %esi            # imm = 0xBB8
callq 0xdd30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_rbtree_insert_value
static void
qq_wifi_device_rbtree_insert_value(qq_rbtree_node_t *temp,
    qq_rbtree_node_t *node, qq_rbtree_node_t *sentinel)
{
    qq_wifi_device_rbtree_node_t   *n, *t;
    qq_rbtree_node_t               **p;

    for ( ;; ) {
        n = (qq_wifi_device_rbtree_node_t *) node;
        t = (qq_wifi_device_rbtree_node_t *) temp;

        if (node->key != temp->key) {
            p = (node->key < temp->key) ? &temp->left : &temp->right;
        } else {
            p = (memcmp(n->id, t->id, 16) < 0)
                 ? &temp->left : &temp->right;
        }

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    qq_rbt_red(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd9b8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xd9a2
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0xd9ae
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xd9f9
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
movl $0x10, %edx
callq 0x20f0
cmpl $0x0, %eax
jge 0xd9e5
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0xd9f1
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xda08
jmp 0xda18
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd964
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_md5_confirm
static qq_int_t
qq_wifi_device_md5_confirm(char *id, u_char *pwd)
{
    MD5_CTX   md5;
    u_char    md5_pwd[16];

    memcpy(&qq_wifi_device_md5_str[qq_wifi_device_md5_id_str_pos], id, 32);

    MD5Init(&md5);
    MD5Update(&md5, qq_wifi_device_md5_str, strlen((char *)qq_wifi_device_md5_str));
    MD5Final(&md5, md5_pwd);

    if (memcmp(pwd, md5_pwd, 16) == 0) {
        return QQ_OK;
    }

    return QQ_WIFI_DEVICE_MD5_FAILED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x6376(%rip), %rcx      # 0x14760
movq -0x10(%rbp), %rdx
leaq 0x637b(%rip), %rax      # 0x14770
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax,%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rax,%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax,%rcx)
leaq -0x70(%rbp), %rdi
callq 0xa360
leaq 0x6349(%rip), %rdi      # 0x14770
callq 0x20e0
movl %eax, %edx
leaq -0x70(%rbp), %rdi
leaq 0x6337(%rip), %rsi      # 0x14770
callq 0xa3b0
leaq -0x80(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xb400
movq -0x18(%rbp), %rax
leaq -0x80(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe47b
movq $0x0, -0x8(%rbp)
jmp 0xe483
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_conflict_confirm
static qq_int_t
qq_wifi_device_conflict_confirm(u_char *id, u_char *mac)
{
    qq_wifi_device_rbtree_node_t  *node;
    qq_wifi_device_t              *wd;

    node = qq_wifi_device_rbtree_lookup(&qq_wifi_device_rbtree, id);

    if (node == NULL) {
        return QQ_OK;
    }
    else {
        wd = (qq_wifi_device_t *) ((char *) node - offsetof(qq_wifi_device_t, rbtree));
        if (memcmp(wd->mac, mac, 6) == 0) {
            return QQ_OK;
        }
    }

    return QQ_WIFI_DEVICE_CONFLICT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x629d(%rip), %rdi      # 0x14748
callq 0xe6d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe4c5
movq $0x0, -0x8(%rbp)
jmp 0xe500
movq -0x20(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
movl $0x6, %edx
callq 0x20f0
cmpl $0x0, %eax
jne 0xe4f6
movq $0x0, -0x8(%rbp)
jmp 0xe500
jmp 0xe4f8
movq $0x7, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_wifi_device.c
// Function: qq_wifi_device_rbtree_lookup
static qq_wifi_device_rbtree_node_t *
qq_wifi_device_rbtree_lookup(qq_rbtree_t *rbtree, u_char *id)
{
    qq_int_t                       rc;
    qq_wifi_device_rbtree_node_t  *n;
    qq_rbtree_node_t              *node, *sentinel;
    uint32_t                       hash;

    node = rbtree->root;
    sentinel = rbtree->sentinel;
    hash = qq_wifi_device_rbtree_key(id);

    while (node != sentinel) {
        n = (qq_wifi_device_rbtree_node_t *) node;

        if (hash != node->key) {
            node = (hash < node->key) ? node->left : node->right;
            continue;
        }

        rc = memcmp(id, n->id, 16);
        if (rc < 0) {
            node = node->left;
            continue;
        }
        if (rc > 0) {
            node = node->right;
            continue;
        }

        return n;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xe7a8
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
je 0xe752
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xe73c
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe748
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xe700
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
movl $0x10, %edx
callq 0x20f0
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0xe786
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xe700
cmpq $0x0, -0x20(%rbp)
jle 0xe79e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xe700
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Summation_lock_synchronzied_cppThread/code11.cpp
// Function: sumUp(unsigned long long&, std::vector<int, std::allocator<int>> const&, unsigned long long, unsigned long long)
void sumUp(unsigned long long& sum, const std::vector<int>& val, unsigned long long beg, unsigned long long end) {
	for (auto it = beg; it < end; ++it) {
		myMutex.lock();
		sum += val[it];
		myMutex.unlock();
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x233e
leaq 0x6ded(%rip), %rdi      # 0x90f0
callq 0x2890
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x28c0
movslq (%rax), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
leaq 0x6dc5(%rip), %rdi      # 0x90f0
callq 0x28e0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x22f1
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/b5compat.c
// Function: permanentwritespritetile
void permanentwritespritetile(int thex, int they, short tilenum, signed char shade,
        int cx1, int cy1, int cx2, int cy2, unsigned char dapalnum) {
    int x, y, xsiz, ysiz, tx1, ty1, tx2, ty2;
    
    (void)thex; (void)they;
    xsiz = tilesizx[tilenum]; tx1 = cx1/xsiz; tx2 = cx2/xsiz;
    ysiz = tilesizy[tilenum]; ty1 = cy1/ysiz; ty2 = cy2/ysiz;
    
    for (x=tx1;x<=tx2;x++) {
        for (y=ty1;y<=ty2;y++) {
            rotatesprite(x*xsiz<<16,y*ysiz<<16,65536L,0,tilenum,shade,
                         dapalnum,8+16+64+128,cx1,cy1,cx2,cy2);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movb %cl, %al
movw %dx, %cx
movb 0x20(%rbp), %dl
movl 0x18(%rbp), %edx
movl 0x10(%rbp), %edx
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movswq -0x1a(%rbp), %rcx
leaq 0x5fece6(%rip), %rax    # 0x608050
movswl (%rax,%rcx,2), %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
cltd
idivl -0x30(%rbp)
movl %eax, -0x38(%rbp)
movl 0x10(%rbp), %eax
cltd
idivl -0x30(%rbp)
movl %eax, -0x40(%rbp)
movswq -0x1a(%rbp), %rcx
leaq 0x5f047f(%rip), %rax    # 0x5f9810
movswl (%rax,%rcx,2), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %eax
cltd
idivl -0x34(%rbp)
movl %eax, -0x3c(%rbp)
movl 0x18(%rbp), %eax
cltd
idivl -0x34(%rbp)
movl %eax, -0x44(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x40(%rbp), %eax
jg 0x944c
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jg 0x943c
movl -0x28(%rbp), %edi
imull -0x30(%rbp), %edi
shll $0x10, %edi
movl -0x2c(%rbp), %esi
imull -0x34(%rbp), %esi
shll $0x10, %esi
movw -0x1a(%rbp), %r8w
movb -0x1b(%rbp), %r9b
movb 0x20(%rbp), %r14b
movl -0x20(%rbp), %ebx
movl -0x24(%rbp), %r11d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl $0x10000, %edx          # imm = 0x10000
xorl %ecx, %ecx
movswl %r8w, %r8d
movsbl %r9b, %r9d
movzbl %r14b, %r14d
movl %r14d, (%rsp)
movl $0xd8, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x93c4
jmp 0x943e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x93b2
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/b5compat.c
// Function: printext
void printext(int x, int y, char *buffer, short tilenum, unsigned char invisiblecol)
{
    int i;
    unsigned char ch;
    
    (void)invisiblecol;

    for(i=0;buffer[i]!=0;i++) {
        ch = (unsigned char)buffer[i];
        rotatesprite((x-((ch&15)<<3))<<16,(y-((ch>>4)<<3))<<16,65536L,0,tilenum,0,0,8+16+128,x,y,x+7,y+7);
        x += 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movb %r8b, %al
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x9651
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %edi
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
shll $0x3, %eax
subl %eax, %edi
shll $0x10, %edi
movl -0x10(%rbp), %esi
movzbl -0x21(%rbp), %eax
sarl $0x4, %eax
shll $0x3, %eax
subl %eax, %esi
shll $0x10, %esi
movw -0x1a(%rbp), %r8w
movl -0xc(%rbp), %ebx
movl -0x10(%rbp), %r11d
movl -0xc(%rbp), %r10d
addl $0x7, %r10d
movl -0x10(%rbp), %eax
addl $0x7, %eax
movl $0x10000, %edx          # imm = 0x10000
xorl %r9d, %r9d
movl %r9d, %ecx
movswl %r8w, %r8d
movl $0x0, (%rsp)
movl $0x98, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x95a4
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekchng.c
// Function: changescore
void
changescore(short snum, short deltascore)
{
     if( toggles[TOGGLE_GODMODE] != 0 ) {
          return;
     }

     score[snum] += deltascore;
     score[snum]&=0xFFFFFFFE;

     if( (score[snum] < 0) || (score[snum] > 99999999) )
          score[snum]=0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
leaq 0x110077(%rip), %rax    # 0x11a000
cmpl $0x0, 0x1c(%rax)
je 0x9f91
jmp 0xa004
movswl -0x4(%rbp), %edx
movswq -0x2(%rbp), %rcx
leaq 0x16c69f(%rip), %rax    # 0x176640
addl (%rax,%rcx,4), %edx
leaq 0x16c695(%rip), %rax    # 0x176640
movl %edx, (%rax,%rcx,4)
movswq -0x2(%rbp), %rcx
leaq 0x16c686(%rip), %rax    # 0x176640
movl (%rax,%rcx,4), %edx
andl $-0x2, %edx
leaq 0x16c679(%rip), %rax    # 0x176640
movl %edx, (%rax,%rcx,4)
movswq -0x2(%rbp), %rcx
leaq 0x16c66a(%rip), %rax    # 0x176640
cmpl $0x0, (%rax,%rcx,4)
jl 0x9ff1
movswq -0x2(%rbp), %rcx
leaq 0x16c658(%rip), %rax    # 0x176640
cmpl $0x5f5e0ff, (%rax,%rcx,4) # imm = 0x5F5E0FF
jle 0xa004
movswq -0x2(%rbp), %rcx
leaq 0x16c643(%rip), %rax    # 0x176640
movl $0x0, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekchng.c
// Function: tekchangestun
void
tekchangestun(short snum,short deltastun)
{
     if( toggles[TOGGLE_GODMODE] != 0 ) {
          return;
     }

     switch (difficulty) {
     case 1:
          deltastun/=2;
          break;
     case 3:
          deltastun*=2;
          break;
     }
     stun[snum]+=deltastun;
     if (stun[snum] < 0) {
          stun[snum]=0;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
leaq 0x10ffd7(%rip), %rax    # 0x11a000
cmpl $0x0, 0x1c(%rax)
je 0xa031
jmp 0xa0ac
leaq 0x16ff90(%rip), %rax    # 0x179fc8
movl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0xa04e
jmp 0xa044
movl -0x8(%rbp), %eax
subl $0x3, %eax
je 0xa060
jmp 0xa06a
movswl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0x4(%rbp)
jmp 0xa06a
movswl -0x4(%rbp), %eax
shll %eax
movw %ax, -0x4(%rbp)
movswl -0x4(%rbp), %edx
movswq -0x2(%rbp), %rcx
leaq 0x123696(%rip), %rax    # 0x12d710
addl (%rax,%rcx,4), %edx
leaq 0x12368c(%rip), %rax    # 0x12d710
movl %edx, (%rax,%rcx,4)
movswq -0x2(%rbp), %rcx
leaq 0x12367d(%rip), %rax    # 0x12d710
cmpl $0x0, (%rax,%rcx,4)
jge 0xa0ac
movswq -0x2(%rbp), %rcx
leaq 0x12366b(%rip), %rax    # 0x12d710
movl $0x0, (%rax,%rcx,4)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekchng.c
// Function: tekhealstun
void
tekhealstun(short snum)
{
     if( toggles[TOGGLE_GODMODE] != 0 ) {
          return;
     }

     if (stun[snum] < MAXSTUNPOINTS) {
          if (stuntics[snum] >= CLKIPS) {
               stuntics[snum]-=CLKIPS;
               tekchangestun(snum,1);
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq 0x10ff3a(%rip), %rax    # 0x11a000
cmpl $0x0, 0x1c(%rax)
je 0xa0ce
jmp 0xa121
movswq -0x2(%rbp), %rcx
leaq 0x123636(%rip), %rax    # 0x12d710
cmpl $0x3e8, (%rax,%rcx,4)   # imm = 0x3E8
jge 0xa121
movswq -0x2(%rbp), %rcx
leaq 0x123661(%rip), %rax    # 0x12d750
cmpl $0x78, (%rax,%rcx,4)
jl 0xa11f
movswq -0x2(%rbp), %rcx
leaq 0x12364f(%rip), %rax    # 0x12d750
movl (%rax,%rcx,4), %edx
subl $0x78, %edx
leaq 0x123642(%rip), %rax    # 0x12d750
movl %edx, (%rax,%rcx,4)
movl $0x1, %esi
movswl -0x2(%rbp), %edi
callq 0xa010
jmp 0xa121
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)