LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connection_write
static int
connection_write(struct chunk *c, int fd) {
  if (c->length == c->done) return 1;

  ssize_t n;
  do {
    n = write(fd, c->data + c->done, c->length - c->done);
  } while (n == -1 && errno == EINTR);

  if (n < 0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK) return 1;
    return 0;
  } else if (n == 0) {
    return 0;
  } else {
    c->done += n;
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x23ab
movl $0x1, -0x4(%rbp)
jmp 0x2453
jmp 0x23ad
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x1090
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x23f7
callq 0x1050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x23ad
cmpq $0x0, -0x20(%rbp)
jge 0x242b
callq 0x1050
cmpl $0xb, (%rax)
je 0x2419
callq 0x1050
cmpl $0xb, (%rax)
jne 0x2422
movl $0x1, -0x4(%rbp)
jmp 0x2453
movl $0x0, -0x4(%rbp)
jmp 0x2453
cmpq $0x0, -0x20(%rbp)
jne 0x243b
movl $0x0, -0x4(%rbp)
jmp 0x2453
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x14(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: chunk_free
static void
chunk_free(struct chunk **head, struct chunk **tail) {
  if ((*head)->next)
    (*head)->next->last = NULL;

  struct chunk *next = (*head)->next;
  free(*head);

  if (*tail == *head) *tail = NULL;
  *head = next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x248f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x24c4
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: chunks_move
static void
chunks_move(struct chunk **tohead, struct chunk **totail,
            struct chunk **fromhead, struct chunk **fromtail) {
  struct chunk *c, *next;

  for (c = *fromhead; c; c = next) {
    next = c->next;
    chunk_nq(c, tohead, totail);
  }

  *fromhead = *fromtail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2530
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2190
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2503
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_alloc.c
// Function: qq_alloc
void *
qq_alloc(size_t size)
{
    void  *p;

    p = malloc(size);
    if (p == NULL) {
        qq_log_error(errno, "malloc(%uz) failed", size);
    }

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2370
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24a9
callq 0x2030
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0xcb62(%rip), %rsi      # 0xf004
movb $0x0, %al
callq 0x9cc0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_alloc.c
// Function: qq_calloc
void *
qq_calloc(size_t size)
{
    void  *p;

    p = qq_alloc(size);

    if (p) {
        memset(p, 0, size);
    }

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2470
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24ef
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x2170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_alloc.c
// Function: qq_memalign
void *
qq_memalign(size_t alignment, size_t size)
{
    void  *p;

    p = memalign(alignment, size);
    if (p == NULL) {
        qq_log_error(errno, "memalign(%uz, %uz) failed", alignment, size);
    }

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2545
callq 0x2030
movl (%rax), %edi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xcad9(%rip), %rsi      # 0xf017
movb $0x0, %al
callq 0x9cc0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_android_app.c
// Function: qq_android_app_init
qq_int_t
qq_android_app_init(qq_cycle_t *cycle)
{
    if (qq_add_listening_config(SOCK_STREAM,
        QQ_ANDROID_APP_TCP_LISTENING_PORT,
        QQ_ANDROID_APP_TCP_LISTENING_POOL_SIZE,
        qq_android_app_init_connection_handler) == QQ_ERROR)
    {
        qq_log_error(0, "qq_android_app_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 $0x1, %edi
movl $0x2af8, %esi           # imm = 0x2AF8
movl $0x400, %edx            # imm = 0x400
leaq 0x3e(%rip), %rcx        # 0x25b0
callq 0x90f0
cmpq $-0x1, %rax
jne 0x2597
xorl %edi, %edi
leaq 0xcaab(%rip), %rsi      # 0xf031
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x259f
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_android_app.c
// Function: qq_android_app_init_connection_handler
static void
qq_android_app_init_connection_handler(qq_connection_t *c)
{
    qq_event_t   *rev, *wev;

    qq_log_debug("qq_android_app_init_connection_handler()");

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

    wev = c->write;
    wev->handler = qq_android_app_write_event_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcabc(%rip), %rdi      # 0xf07f
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6f(%rip), %rcx        # 0x2650
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0xb4(%rip), %rcx        # 0x26b0
movq %rcx, 0x10(%rax)
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_android_app.c
// Function: qq_android_app_read_event_handler
static void
qq_android_app_read_event_handler(qq_event_t *ev)
{
    qq_log_debug("qq_android_app_read_event_handler()");

    qq_connection_t   *c;
    u_char             buf[3];
    int                len;

    c = ev->data;
    len = c->recv(c, buf, 3);

    c->send(c, buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xca45(%rip), %rdi      # 0xf0a8
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x13(%rbp), %rsi
movl $0x3, %edx
callq *%rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x13(%rbp), %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_app.c
// Function: qq_app_init
qq_int_t
qq_app_init(qq_cycle_t *cycle)
{
    if (qq_mysql_init() == QQ_ERROR) {
        qq_log_error(0, "qq_mysql_init() failed");
        return QQ_ERROR;
    }

    if (qq_ios_app_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_ios_app_init() failed");
        return QQ_ERROR;
    }

    if (qq_android_app_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_android_app_init() failed");
        return QQ_ERROR;
    }

    if (qq_wifi_device_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_wifi_device_init() failed");
        return QQ_ERROR;
    }

    if (qq_video_audio_device_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_video_audio_device_init() failed");
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0xb610
cmpq $-0x1, %rax
jne 0x2704
xorl %edi, %edi
leaq 0xca01(%rip), %rsi      # 0xf0f1
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x27b3
movq -0x10(%rbp), %rdi
callq 0x4b90
cmpq $-0x1, %rax
jne 0x2730
xorl %edi, %edi
leaq 0xc9ec(%rip), %rsi      # 0xf108
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x27b3
movq -0x10(%rbp), %rdi
callq 0x2550
cmpq $-0x1, %rax
jne 0x2759
xorl %edi, %edi
leaq 0xc9d9(%rip), %rsi      # 0xf121
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x27b3
movq -0x10(%rbp), %rdi
callq 0xd810
cmpq $-0x1, %rax
jne 0x2782
xorl %edi, %edi
leaq 0xc9cd(%rip), %rsi      # 0xf13e
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x27b3
movq -0x10(%rbp), %rdi
callq 0xd720
cmpq $-0x1, %rax
jne 0x27ab
xorl %edi, %edi
leaq 0xc9c1(%rip), %rsi      # 0xf15b
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x27b3
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_app.c
// Function: qq_app_done
void
qq_app_done(qq_cycle_t *cycle)
{
    qq_log_debug("qq_app_done()");

    qq_mysql_close();
    qq_ios_app_done();
    qq_android_app_done();
    qq_wifi_device_done();
    qq_video_audio_device_done();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc9ac(%rip), %rdi      # 0xf17f
movb $0x0, %al
callq 0x9e70
callq 0xb700
callq 0x4c60
callq 0x2610
callq 0xda60
callq 0xd7f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_app.c
// Function: qq_app_close_connection
void
qq_app_close_connection(qq_connection_t *c)
{
    qq_pool_t  *pool;

    qq_log_debug("qq_app_close_connection(fd:%d)", c->fd);

    c->destroyed = 1;

    pool = c->pool;

    qq_close_connection(c);

    qq_destroy_pool(pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xc973(%rip), %rdi      # 0xf18d
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movb 0x98(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b10
movq -0x10(%rbp), %rdi
callq 0x2368
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_buf.c
// Function: qq_create_temp_buf
qq_buf_t *
qq_create_temp_buf(qq_pool_t *pool, size_t size)
{
    qq_buf_t *b;

    b = qq_calloc_buf(pool);
    if (b == NULL) {
        return NULL;
    }

    b->start = qq_palloc(pool, size);
    if (b->start == NULL) {
        return NULL;
    }

    b->pos = b->start;
    b->last = b->start;
    b->end = b->last + size;
    b->temporary = 1;

    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0xbb60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2893
movq $0x0, -0x8(%rbp)
jmp 0x290f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xba90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x28c0
movq $0x0, -0x8(%rbp)
jmp 0x290f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movw 0x30(%rax), %cx
andw $-0x2, %cx
orw $0x1, %cx
movw %cx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_cycle.c
// Function: qq_cycle_init
qq_int_t
qq_cycle_init(void)
{
    qq_pool_t          *pool;
    qq_cycle_t         *cycle;

    pool = qq_create_pool(QQ_CYCLE_POOL_SIZE);
    if (pool == NULL) {
        qq_log_error(0, "qq_create_pool(%d) failed", QQ_CYCLE_POOL_SIZE);
        return QQ_ERROR;
    }

    cycle = qq_pcalloc(pool, sizeof(qq_cycle_t));
    if (cycle == NULL) {
        qq_log_error(0, "qq_pcalloc() failed");
        qq_destroy_pool(pool);
        return QQ_ERROR;
    }
    cycle->pool = pool;
    qq_cycle = cycle;

    if (qq_app_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_app_init() failed");
        return QQ_ERROR;
    }

    if (qq_create_listening(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_create_listening() failed");
        return QQ_ERROR;
    }

    if (qq_open_listening_sockets(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_open_listening_sockets() failed");
        return QQ_ERROR;
    }

    if (qq_configure_listening_sockets(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_configure_listening_sockets() failed");
        return QQ_ERROR;
    }

    if (qq_event_init(cycle) == QQ_ERROR) {
        qq_log_error(0, "qq_event_init() failed");
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x4000, %edi           # imm = 0x4000
callq 0xba30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d7f
xorl %edi, %edi
leaq 0xc4fb(%rip), %rsi      # 0xf261
movl $0x4000, %edx           # imm = 0x4000
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x10(%rbp), %rdi
movl $0x58, %esi
callq 0xbb60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2dbe
xorl %edi, %edi
leaq 0xc4da(%rip), %rsi      # 0xf27b
movb $0x0, %al
callq 0x9cc0
movq -0x10(%rbp), %rdi
callq 0x2368
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x1150c(%rip)     # 0x142e0
movq -0x18(%rbp), %rdi
callq 0x26d0
cmpq $-0x1, %rax
jne 0x2e00
xorl %edi, %edi
leaq 0xc4a3(%rip), %rsi      # 0xf28f
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x18(%rbp), %rdi
callq 0x9200
cmpq $-0x1, %rax
jne 0x2e2c
xorl %edi, %edi
leaq 0xc48c(%rip), %rsi      # 0xf2a4
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x18(%rbp), %rdi
callq 0x94a0
cmpq $-0x1, %rax
jne 0x2e55
xorl %edi, %edi
leaq 0xc47d(%rip), %rsi      # 0xf2c1
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x18(%rbp), %rdi
callq 0x98f0
cmpq $-0x1, %rax
jne 0x2e7e
xorl %edi, %edi
leaq 0xc477(%rip), %rsi      # 0xf2e4
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq -0x18(%rbp), %rdi
callq 0x3880
cmpq $-0x1, %rax
jne 0x2ea7
xorl %edi, %edi
leaq 0xc476(%rip), %rsi      # 0xf30c
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2eaf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_cycle.c
// Function: qq_cycle_done
void
qq_cycle_done(void)
{
    qq_log_debug("qq_cycle_done()");

    qq_close_listening_sockets(qq_cycle);

    qq_app_done(qq_cycle);

    qq_event_done(qq_cycle);

    qq_destroy_pool(qq_cycle->pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xc458(%rip), %rdi      # 0xf323
movb $0x0, %al
callq 0x9e70
movq 0x11407(%rip), %rdi     # 0x142e0
callq 0x9a00
movq 0x113fb(%rip), %rdi     # 0x142e0
callq 0x27c0
movq 0x113ef(%rip), %rdi     # 0x142e0
callq 0x3d10
movq 0x113e3(%rip), %rax     # 0x142e0
movq (%rax), %rdi
callq 0x2368
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_epoll.c
// Function: qq_epoll_init
qq_int_t
qq_epoll_init(void)
{
    if (ep == -1) {
        ep = epoll_create(QQ_CONNECTION_NUMBER);

        if (ep == -1) {
            qq_log_error(errno, "epoll_create() failed");
            return QQ_ERROR;
        }
    }

    nevents = QQ_EPOLL_EVENT_NUMBER;
    if (event_list) {
        free(event_list);
    }
    event_list = qq_alloc(sizeof(struct epoll_event) * nevents);
    if (event_list == NULL) {
        qq_log_error(0, "epoll_event malloc(%d) failed", nevents);
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x112a1(%rip)    # 0x141c0
jne 0x2f5b
movl $0x4e20, %edi           # imm = 0x4E20
callq 0x2340
movl %eax, 0x1128f(%rip)     # 0x141c0
cmpl $-0x1, 0x11288(%rip)    # 0x141c0
jne 0x2f59
callq 0x2030
movl (%rax), %edi
leaq 0xc3eb(%rip), %rsi      # 0xf333
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2fc3
jmp 0x2f5b
movq $0x2710, 0x11382(%rip) # imm = 0x2710
cmpq $0x0, 0x11382(%rip)     # 0x142f0
je 0x2f7c
movq 0x11379(%rip), %rdi     # 0x142f0
callq 0x2368
imulq $0xc, 0x11364(%rip), %rdi # 0x142e8
callq 0x2470
movq %rax, 0x11360(%rip)     # 0x142f0
cmpq $0x0, 0x11358(%rip)     # 0x142f0
jne 0x2fbb
movq 0x11347(%rip), %rdx     # 0x142e8
xorl %edi, %edi
leaq 0xc39f(%rip), %rsi      # 0xf349
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x2fc3
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/event/qq_epoll.c
// Function: qq_epoll_done
void
qq_epoll_done(void)
{
    qq_log_debug("qq_epoll_done()");

    if (close(ep) == -1) {
        qq_log_error(errno, "epoll close() failed");
    }
    ep = -1;

    free(event_list);
    event_list = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xc38c(%rip), %rdi      # 0xf367
movb $0x0, %al
callq 0x9e70
movl 0x111d8(%rip), %edi     # 0x141c0
callq 0x2350
cmpl $-0x1, %eax
jne 0x3007
callq 0x2030
movl (%rax), %edi
leaq 0xc377(%rip), %rsi      # 0xf377
movb $0x0, %al
callq 0x9cc0
movl $0xffffffff, 0x111af(%rip) # imm = 0xFFFFFFFF
movq 0x112d8(%rip), %rdi     # 0x142f0
callq 0x2368
movq $0x0, 0x112c8(%rip) # 0x142f0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_epoll.c
// Function: qq_epoll_add_event
qq_int_t
qq_epoll_add_event(qq_event_t *ev, qq_int_t event)
{
    int                  op;
    uint32_t             events, prev;
    qq_event_t          *e;
    qq_connection_t     *c;
    struct epoll_event   ee;

    c = ev->data;

    if (event == QQ_READ_EVENT) {
        e = c->write;
        prev = EPOLLOUT;
        events = EPOLLIN|EPOLLRDHUP;
    } else {
        e = c->read;
        prev = EPOLLIN|EPOLLRDHUP;
        events = EPOLLOUT;
    }

    if (e->active) {
        op = EPOLL_CTL_MOD;
        events |= prev;
    } else {
        op = EPOLL_CTL_ADD;
    }

    ee.events = events | EPOLLET;
    ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);

    qq_log_debug("epoll add event: fd:%d op:%d ev:%08XD", c->fd, op, ee.events);

    if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
        qq_log_error(errno, "epoll_ctl(%d, %d) failed", op, c->fd);
        return QQ_ERROR;
    }

    ev->active = 1;

    return QQ_OK;
}

// 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, -0x38(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x306e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x4, -0x24(%rbp)
movl $0x2001, -0x20(%rbp)    # imm = 0x2001
jmp 0x3088
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x2001, -0x24(%rbp)    # imm = 0x2001
movl $0x4, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x30ac
movl $0x3, -0x1c(%rbp)
movl -0x24(%rbp), %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x30b3
movl $0x1, -0x1c(%rbp)
movl -0x20(%rbp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
movl %ecx, %ecx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl 0x18(%rax), %esi
movl -0x1c(%rbp), %edx
movl -0x44(%rbp), %ecx
leaq 0xc2a0(%rip), %rdi      # 0xf38c
movb $0x0, %al
callq 0x9e70
movl 0x110c7(%rip), %edi     # 0x141c0
movl -0x1c(%rbp), %esi
movq -0x38(%rbp), %rax
movl 0x18(%rax), %edx
leaq -0x44(%rbp), %rcx
callq 0x2280
cmpl $-0x1, %eax
jne 0x313a
callq 0x2030
movl (%rax), %edi
movl -0x1c(%rbp), %edx
movq -0x38(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0xc289(%rip), %rsi      # 0xf3b2
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x3152
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x8, %ecx
movl %ecx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_epoll.c
// Function: qq_epoll_del_event
qq_int_t
qq_epoll_del_event(qq_event_t *ev, qq_int_t event)
{
    int                  op;
    uint32_t             prev;
    qq_event_t          *e;
    qq_connection_t     *c;
    struct epoll_event   ee;

    c = ev->data;

    if (event == QQ_READ_EVENT) {
        e = c->write;
        prev = EPOLLOUT;
    } else {
        e = c->read;
        prev = EPOLLIN|EPOLLRDHUP;
    }

    if (e->active) {
        op = EPOLL_CTL_MOD;
        ee.events = prev | EPOLLET;
        ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);
    } else {
        op = EPOLL_CTL_DEL;
        ee.events = 0;
        ee.data.ptr = NULL;
    }

    qq_log_debug("epoll del event: fd:%d op:%d ev:%08XD", c->fd, op, ee.events);

    if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
        qq_log_error(errno, "epoll_ctl(%d, %d) failed", op, c->fd);
        return QQ_ERROR;
    }

    ev->active = 0;

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x3197
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x4, -0x20(%rbp)
jmp 0x31aa
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x2001, -0x20(%rbp)    # imm = 0x2001
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31ea
movl $0x3, -0x1c(%rbp)
movl -0x20(%rbp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
movl %ecx, %ecx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x3200
movl $0x2, -0x1c(%rbp)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %esi
movl -0x1c(%rbp), %edx
movl -0x3c(%rbp), %ecx
leaq 0xc1b7(%rip), %rdi      # 0xf3cb
movb $0x0, %al
callq 0x9e70
movl 0x10f9f(%rip), %edi     # 0x141c0
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rax
movl 0x18(%rax), %edx
leaq -0x3c(%rbp), %rcx
callq 0x2280
cmpl $-0x1, %eax
jne 0x3262
callq 0x2030
movl (%rax), %edi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0xc161(%rip), %rsi      # 0xf3b2
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x327a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_epoll.c
// Function: qq_epoll_add_connection
qq_int_t
qq_epoll_add_connection(qq_connection_t *c)
{
    struct epoll_event  ee;

    ee.events = EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP;
    ee.data.ptr = (void *) ((uintptr_t) c | c->read->instance);

    qq_log_debug("epoll add connection: fd:%d ev:%08XD", c->fd, ee.events);

    if (epoll_ctl(ep, EPOLL_CTL_ADD, c->fd, &ee) == -1) {
        qq_log_error(errno, "epoll_ctl(EPOLL_CTL_ADD, %d) failed", c->fd);
        return QQ_ERROR;
    }

    c->read->active = 1;
    c->write->active = 1;

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x80002005, -0x1c(%rbp) # imm = 0x80002005
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0x8(%rcx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
movl %ecx, %ecx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movl -0x1c(%rbp), %edx
leaq 0xc11f(%rip), %rdi      # 0xf3f1
movb $0x0, %al
callq 0x9e70
movl 0x10ee1(%rip), %edi     # 0x141c0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2280
cmpl $-0x1, %eax
jne 0x331f
callq 0x2030
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0xc108(%rip), %rsi      # 0xf416
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x334f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x8, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x8, %ecx
movl %ecx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_epoll.c
// Function: qq_epoll_del_connection
qq_int_t
qq_epoll_del_connection(qq_connection_t *c)
{
    struct epoll_event  ee;

    qq_log_debug("epoll del connection: fd:%d", c->fd);

    ee.events = 0;
    ee.data.ptr = NULL;

    if (epoll_ctl(ep, EPOLL_CTL_DEL, c->fd, &ee) == -1) {
        qq_log_error(errno, "epoll_ctl(EPOLL_CTL_DEL, %d) failed", c->fd);
        return QQ_ERROR;
    }

    c->read->active = 0;
    c->write->active = 0;

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xc0c0(%rip), %rdi      # 0xf43a
movb $0x0, %al
callq 0x9e70
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
movl 0x10e2a(%rip), %edi     # 0x141c0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movl $0x2, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2280
cmpl $-0x1, %eax
jne 0x33d6
callq 0x2030
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0xc091(%rip), %rsi      # 0xf456
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x3406
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %ecx
andl $-0x9, %ecx
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event.c
// Function: qq_events_process
void
qq_events_process(void)
{
    qq_msec_t  delta;

    delta = qq_current_msec;

    qq_epoll_process_events(qq_event_find_timer(), QQ_UPDATE_TIME);

    delta = qq_current_msec - delta;
    qq_log_debug("timer delta: %d", delta);

    qq_event_process_posted(&qq_posted_accept_events);

    if (delta) {
        qq_event_expire_timers();
    }

    qq_event_process_posted(&qq_posted_events);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10a51(%rip), %rax     # 0x146f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
callq 0x4980
movq %rax, %rdi
movl $0x1, %esi
callq 0x3410
leaq 0x10a31(%rip), %rax     # 0x146f0
movq (%rax), %rax
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xb951(%rip), %rdi      # 0xf626
movb $0x0, %al
callq 0x9e70
leaq 0x10615(%rip), %rdi     # 0x142f8
callq 0x4880
cmpq $0x0, -0x8(%rbp)
je 0x3cf4
callq 0x4a40
leaq 0x1060d(%rip), %rdi     # 0x14308
callq 0x4880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event.c
// Function: qq_event_done
void
qq_event_done(qq_cycle_t *cycle)
{
    qq_log_debug("qq_event_done()");

    qq_epoll_done();

    free(cycle->connections);

    free(cycle->read_events);

    free(cycle->write_events);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb913(%rip), %rdi      # 0xf636
movb $0x0, %al
callq 0x9e70
callq 0x2fd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2368
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2368
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2368
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event.c
// Function: qq_handle_read_event
qq_int_t
qq_handle_read_event(qq_event_t *rev)
{
    if (!rev->active && !rev->ready) {
        if (qq_epoll_add_event(rev, QQ_READ_EVENT)
            == QQ_ERROR)
        {
            return QQ_ERROR;
        }
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3db0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x5, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3db0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3030
cmpq $-0x1, %rax
jne 0x3dae
movq $-0x1, -0x8(%rbp)
jmp 0x3db8
jmp 0x3db0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_accept.c
// Function: qq_enable_accept_events
static qq_int_t
qq_enable_accept_events(qq_cycle_t *cycle)
{
    qq_uint_t         i;
    qq_listening_t   *ls;
    qq_connection_t  *c;

    ls = cycle->listening;
    for (i = 0; i < cycle->nlistening; i++) {
        c = ls[i].connection;
        if (c == NULL || c->read->active) {
            continue;
        }

        if (qq_epoll_add_event(c->read, QQ_READ_EVENT) == QQ_ERROR) {
            return QQ_ERROR;
        }
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x4213
movq -0x20(%rbp), %rax
imulq $0x60, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x41df
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x41e1
jmp 0x4205
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x3030
cmpq $-0x1, %rax
jne 0x4203
movq $-0x1, -0x8(%rbp)
jmp 0x421b
jmp 0x4205
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x41a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_accept.c
// Function: qq_close_accepted_connection
static void
qq_close_accepted_connection(qq_connection_t *c)
{
    qq_socket_t  fd;

    qq_free_connection(c);

    fd = c->fd;
    c->fd = (qq_socket_t) -1;

    if (close(fd) == -1) {
        qq_log_error(errno, "close sockets failed");
    }

    if (c->pool) {
        qq_destroy_pool(c->pool);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ac0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %edi
callq 0x2350
cmpl $-0x1, %eax
jne 0x432c
callq 0x2030
movl (%rax), %edi
leaq 0xb365(%rip), %rsi      # 0xf68a
movb $0x0, %al
callq 0x9cc0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4344
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2368
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_posted.c
// Function: qq_event_process_posted
void
qq_event_process_posted(qq_queue_t *posted)
{
    qq_queue_t  *q;
    qq_event_t  *ev;

    while (!qq_queue_empty(posted)) {
        q = qq_queue_head(posted);
        ev = qq_queue_data(q, qq_event_t, queue);

        qq_log_debug("qq_event_process_posted(ev:%p)", ev);

        qq_delete_posted_event(ev);

        ev->handler(ev);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x48a5
jmp 0x492e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x48, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xae8b(%rip), %rdi      # 0xf753
movb $0x0, %al
callq 0x9e70
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq 0xa90d(%rip), %rdi      # 0xf221
movb $0x0, %al
callq 0x9e70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x488c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_timer.c
// Function: qq_event_find_timer
qq_msec_t
qq_event_find_timer(void)
{
    qq_msec_int_t      timer;
    qq_rbtree_node_t  *node, *root, *sentinel;

    if (qq_event_timer_rbtree.root == &qq_event_timer_sentinel) {
        return QQ_TIMER_INFINITE;
    }

    root     = qq_event_timer_rbtree.root;
    sentinel = qq_event_timer_rbtree.sentinel;

    node = qq_rbtree_min(root, sentinel);
    timer = (qq_msec_int_t) (node->key - qq_current_msec);

    return (qq_msec_t) (timer > 0 ? timer : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xf989(%rip), %rax      # 0x14318
cmpq %rax, 0xf9aa(%rip)      # 0x14340
jne 0x49a2
movq $-0x1, -0x8(%rbp)
jmp 0x4a02
movq 0xf997(%rip), %rax      # 0x14340
movq %rax, -0x20(%rbp)
movq 0xf994(%rip), %rax      # 0x14348
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4a10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
leaq 0xfd19(%rip), %rcx      # 0x146f0
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x49f2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x49fa
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x49fa
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_timer.c
// Function: qq_event_expire_timers
void
qq_event_expire_timers(void)
{
    qq_event_t        *ev;
    qq_rbtree_node_t  *node, *root, *sentinel;

    sentinel = qq_event_timer_rbtree.sentinel;

    for ( ;; ) {
        root = qq_event_timer_rbtree.root;

        if (root == sentinel) {
            return;
        }

        node = qq_rbtree_min(root, sentinel);

        /* node->key > qq_current_msec */

        if ((qq_msec_int_t) (node->key - qq_current_msec) > 0) {
            return;
        }

        ev = (qq_event_t *) ((char *) node - offsetof(qq_event_t, timer));
        qq_rbtree_delete(&qq_event_timer_rbtree, &ev->timer);

        ev->timer_set = 0;
        ev->timedout = 1;
        ev->handler(ev);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xf8f9(%rip), %rax      # 0x14348
movq %rax, -0x20(%rbp)
movq 0xf8e6(%rip), %rax      # 0x14340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4a6d
jmp 0x4af6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4a10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0xfc64(%rip), %rcx      # 0x146f0
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jle 0x4a9a
jmp 0x4af6
movq -0x10(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq 0xf88b(%rip), %rdi      # 0x14340
callq 0xc460
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffff7ff, %ecx       # imm = 0xFFFFF7FF
orl $0x0, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x4a53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_inet.c
// Function: qq_sock_ntop
size_t
qq_sock_ntop(struct sockaddr_in *sin, u_char *text)
{
    u_char               *p;

    p = (u_char *) &sin->sin_addr;

    return sprintf(text, "%u.%u.%u.%u:%d",
                   p[0], p[1], p[2], p[3], ntohs(sin->sin_port));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x2320
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movzwl %ax, %eax
leaq 0xabfa(%rip), %rsi      # 0xf772
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2070
cltq
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_ios_app.c
// Function: qq_ios_app_init
qq_int_t
qq_ios_app_init(qq_cycle_t *cycle)
{
    if (qq_add_listening_config(SOCK_STREAM,
        QQ_IOS_APP_TCP_LISTENING_PORT,
        QQ_IOS_APP_TCP_LISTENING_POOL_SIZE,
        qq_ios_app_init_connection_handler) == QQ_ERROR)
    {
        qq_log_error(0, "qq_ios_app_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 $0x1, %edi
movl $0x2710, %esi           # imm = 0x2710
movl $0x400, %edx            # imm = 0x400
leaq 0x3e(%rip), %rcx        # 0x4bf0
callq 0x90f0
cmpq $-0x1, %rax
jne 0x4bd7
xorl %edi, %edi
leaq 0xabbb(%rip), %rsi      # 0xf781
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x4bdf
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_ios_app.c
// Function: qq_ios_app_init_connection_handler
static void
qq_ios_app_init_connection_handler(qq_connection_t *c)
{
    qq_event_t   *rev, *wev;

    qq_log_debug("qq_ios_app_init_connection_handler()");

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

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

    qq_event_add_timer(rev, QQ_IOS_APP_ACCEPT_TIMEOUT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xabc4(%rip), %rdi      # 0xf7c7
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x7f(%rip), %rcx        # 0x4ca0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x284(%rip), %rcx       # 0x4ec0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0xbb8, %esi            # imm = 0xBB8
callq 0x4ee0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/event/qq_event_timer.h
// Function: qq_event_add_timer
static inline void
qq_event_add_timer(qq_event_t *ev, qq_msec_t timer)
{
    qq_msec_t      key;
    qq_msec_int_t  diff;

    key = qq_current_msec + timer;

    if (ev->timer_set) {
        diff = (qq_msec_int_t) (key - ev->timer.key);
        if (qq_abs(diff) < QQ_TIMER_LAZY_DELAY) {
            return;
        }

        qq_event_del_timer(ev);
    }

    ev->timer.key = key;
    qq_rbtree_insert(&qq_event_timer_rbtree, &ev->timer);
    ev->timer_set = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xf7f9(%rip), %rax      # 0x146f0
movq (%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0xb, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f56
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x4f35
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4f3f
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x12c, %rax            # imm = 0x12C
jge 0x4f4d
jmp 0x4f8c
movq -0x8(%rbp), %rdi
callq 0x50e0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq 0xf3cf(%rip), %rdi      # 0x14340
callq 0xbf10
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0xfffff7ff, %ecx       # imm = 0xFFFFF7FF
orl $0x800, %ecx            # imm = 0x800
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_ios_app.c
// Function: qq_ios_app_process_request_handler
static void
qq_ios_app_process_request_handler(qq_event_t *rev)
{
    qq_connection_t   *c;
    ssize_t            n;
    size_t             size;

    c = rev->data;

    if (c->buffer->last - c->buffer->pos > 0) {
        qq_ios_app_process_package(c);
        c->buffer->last = c->buffer->pos;
        return;
    }

    n = c->recv(c, (u_char *)c->buffer->pos,
        (size_t)((uintptr_t)c->buffer->end - (uintptr_t)c->buffer->start));
    if (n == QQ_AGAIN) {
        if (qq_handle_read_event(rev) != QQ_OK) {
            qq_app_close_connection(c);
        }
        return;
    }

    if (n == QQ_ERROR) {
        qq_app_close_connection(c);
        return;
    }

    if (n == 0) {
        qq_log_error(0, "client closed connection");
        qq_app_close_connection(c);
        return;
    }

    c->buffer->last += n;
    qq_ios_app_process_package(c);
    c->buffer->last = c->buffer->pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jle 0x4ffc
movq -0x10(%rbp), %rdi
callq 0x50d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x50bd
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $-0x2, -0x18(%rbp)
jne 0x5055
movq -0x8(%rbp), %rdi
callq 0x3d60
cmpq $0x0, %rax
je 0x5053
movq -0x10(%rbp), %rdi
callq 0x2800
jmp 0x50bd
cmpq $-0x1, -0x18(%rbp)
jne 0x5067
movq -0x10(%rbp), %rdi
callq 0x2800
jmp 0x50bd
cmpq $0x0, -0x18(%rbp)
jne 0x5089
xorl %edi, %edi
leaq 0xa797(%rip), %rsi      # 0xf80e
movb $0x0, %al
callq 0x9cc0
movq -0x10(%rbp), %rdi
callq 0x2800
jmp 0x50bd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x50d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: qq_cjson_init
int qq_cjson_init(size_t size)
{
    void *p;

    p = memalign(16, size);
    if (p == NULL) {
        return -1;
    }

    qq_cjson_buf = (qq_cjson_buf_t *) p;
    qq_cjson_buf->start = (u_char *) p + sizeof(qq_cjson_buf_t);
    qq_cjson_buf->pos = qq_cjson_buf->start;
    qq_cjson_buf->end = (u_char *) p + size;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x10, %edi
callq 0x22d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x514e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x519a
movq -0x18(%rbp), %rax
movq %rax, 0xf1ff(%rip)      # 0x14358
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq 0xf1f0(%rip), %rax      # 0x14358
movq %rcx, (%rax)
movq 0xf1e6(%rip), %rax      # 0x14358
movq (%rax), %rcx
movq 0xf1dc(%rip), %rax      # 0x14358
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq 0xf1c9(%rip), %rax      # 0x14358
movq %rcx, 0x10(%rax)
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/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: cJSON_InitHooks
void cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (!hooks) { /* Reset hooks */
        cJSON_malloc = malloc;
        cJSON_free = free;
        return;
    }

	cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
	cJSON_free	 = (hooks->free_fn)?hooks->free_fn:free;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x520d
movq 0xedea(%rip), %rax      # 0x13fe0
movq %rax, 0xefcb(%rip)      # 0x141c8
movq 0xedd4(%rip), %rax      # 0x13fd8
movq %rax, 0xefc5(%rip)      # 0x141d0
jmp 0x526d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5224
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5231
movq 0xedb5(%rip), %rax      # 0x13fe0
movq %rax, -0x10(%rbp)
jmp 0x5231
movq -0x10(%rbp), %rax
movq %rax, 0xef8c(%rip)      # 0x141c8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5255
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5262
movq 0xed7c(%rip), %rax      # 0x13fd8
movq %rax, -0x18(%rbp)
jmp 0x5262
movq -0x18(%rbp), %rax
movq %rax, 0xef63(%rip)      # 0x141d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: cJSON_Delete
void cJSON_Delete(cJSON *c)
{
	cJSON *next;
	while (c)
	{
		next=c->next;
		if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);
		if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
		if (!(c->type&cJSON_StringIsConst) && c->string) cJSON_free(c->string);
		cJSON_free(c);
		c=next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x532f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x52bb
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x52bb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5270
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x52e8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x52e8
movq 0xeef2(%rip), %rax      # 0x141d0
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x5315
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5315
movq 0xeec5(%rip), %rax      # 0x141d0
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq 0xeeb4(%rip), %rax      # 0x141d0
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x527c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)