LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: cJSON_ParseWithOpts
cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
{
	const char *end=0;
	cJSON *c=cJSON_New_Item();
	ep=0;
	if (!c) return 0;       /* memory fail */

	end=parse_value(c,skip(value));
	if (!end)	{cJSON_Delete(c);return 0;}	/* parse failure. ep is set. */

	/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
	if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}}
	if (return_parse_end) *return_parse_end=end;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
callq 0x5420
movq %rax, -0x30(%rbp)
movq $0x0, 0xeff1(%rip) # 0x14360
cmpq $0x0, -0x30(%rbp)
jne 0x5383
movq $0x0, -0x8(%rbp)
jmp 0x5414
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5460
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x53be
movq -0x30(%rbp), %rdi
callq 0x5270
movq $0x0, -0x8(%rbp)
jmp 0x5414
cmpl $0x0, -0x1c(%rbp)
je 0x53fa
movq -0x28(%rbp), %rdi
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x53f8
movq -0x30(%rbp), %rdi
callq 0x5270
movq -0x28(%rbp), %rax
movq %rax, 0xef72(%rip)      # 0x14360
movq $0x0, -0x8(%rbp)
jmp 0x5414
jmp 0x53fa
cmpq $0x0, -0x18(%rbp)
je 0x540c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: parse_value
static const char *parse_value(cJSON *item,const char *value)
{
	if (!value)						return 0;	/* Fail on null. */
	if (!strncmp(value,"null",4))	{ item->type=cJSON_NULL;  return value+4; }
	if (!strncmp(value,"false",5))	{ item->type=cJSON_False; return value+5; }
	if (!strncmp(value,"true",4))	{ item->type=cJSON_True; item->valueint=1;	return value+4; }
	if (*value=='\"')				{ return parse_string(item,value); }
	if (*value=='-' || (*value>='0' && *value<='9'))	{ return parse_number(item,value); }
	if (*value=='[')				{ return parse_array(item,value); }
	if (*value=='{')				{ return parse_object(item,value); }

	ep=value;return 0;	/* failure. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5484
movq $0x0, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rdi
leaq 0xa4db(%rip), %rsi      # 0xf96a
movl $0x4, %edx
callq 0x2120
cmpl $0x0, %eax
jne 0x54ba
movq -0x10(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rdi
leaq 0xa4aa(%rip), %rsi      # 0xf96f
movl $0x5, %edx
callq 0x2120
cmpl $0x0, %eax
jne 0x54f0
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rdi
leaq 0xa47a(%rip), %rsi      # 0xf975
movl $0x4, %edx
callq 0x2120
cmpl $0x0, %eax
jne 0x5531
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5553
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c20
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x5577
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x558a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x558a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7070
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x55a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7330
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x55c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x74d0
movq %rax, -0x8(%rbp)
jmp 0x55db
movq -0x18(%rbp), %rax
movq %rax, 0xed8d(%rip)      # 0x14360
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %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: cJSON_PrintBuffered
char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt)
{
	printbuffer p;
	p.buffer=(char*)cJSON_malloc(prebuffer);
	p.length=prebuffer;
	p.offset=0;
	return print_value(item,0,fmt,&p);
	return p.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0xe8af(%rip), %rax      # 0x141c8
movslq -0xc(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
leaq -0x20(%rbp), %rcx
callq 0x56b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: cJSON_strdup
static char* cJSON_strdup(const char* str)
{
      size_t len;
      char* copy;

      len = strlen(str) + 1;
      if (!(copy = (char*)cJSON_malloc(len))) return 0;
      memcpy(copy,str,len);
      return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq 0xe564(%rip), %rax      # 0x141c8
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5c7e
movq $0x0, -0x8(%rbp)
jmp 0x5c97
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_json.c
// Function: qq_cjson_malloc
static void *qq_cjson_malloc(size_t size)
{
    u_char  *m;

    qq_log_debug("qq_cjson_malloc(size: %d)", size);

    m = qq_cjson_buf->pos;
    m = qq_cjson_align_ptr(m, QQ_CJSON_ALIGNMENT);

    if ((size_t)(qq_cjson_buf->end - m) >= size) {
        qq_cjson_buf->pos = m + size;
        return m;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x8dd9(%rip), %rdi      # 0xf940
movb $0x0, %al
callq 0x9e70
movq 0xd7e3(%rip), %rax      # 0x14358
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq 0xd7c4(%rip), %rax      # 0x14358
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jb 0x6bc2
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq 0xd7a4(%rip), %rax      # 0x14358
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6bca
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %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: parse_array
static const char *parse_array(cJSON *item,const char *value)
{
	cJSON *child;
	if (*value!='[')	{ep=value;return 0;}	/* not an array! */

	item->type=cJSON_Array;
	value=skip(value+1);
	if (*value==']') return value+1;	/* empty array. */

	item->child=child=cJSON_New_Item();
	if (!item->child) return 0;		 /* memory fail */
	value=skip(parse_value(child,skip(value)));	/* skip any spacing, get the value. */
	if (!value) return 0;

	while (*value==',')
	{
		cJSON *new_item;
		if (!(new_item=cJSON_New_Item())) return 0; 	/* memory fail */
		child->next=new_item;new_item->prev=child;child=new_item;
		value=skip(parse_value(child,skip(value+1)));
		if (!value) return 0;	/* memory fail */
	}

	if (*value==']') return value+1;	/* end of array */
	ep=value;return 0;	/* malformed. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x7364
movq -0x18(%rbp), %rax
movq %rax, 0xd009(%rip)      # 0x14360
movq $0x0, -0x8(%rbp)
jmp 0x74bf
movq -0x10(%rbp), %rax
movl $0x5, 0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x55f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x739d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x74bf
callq 0x5420
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x73c9
movq $0x0, -0x8(%rbp)
jmp 0x74bf
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x55f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5460
movq %rax, %rdi
callq 0x55f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7406
movq $0x0, -0x8(%rbp)
jmp 0x74bf
jmp 0x7408
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x7492
callq 0x5420
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x7430
movq $0x0, -0x8(%rbp)
jmp 0x74bf
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x55f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5460
movq %rax, %rdi
callq 0x55f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x748d
movq $0x0, -0x8(%rbp)
jmp 0x74bf
jmp 0x7408
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x74ac
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x74bf
movq -0x18(%rbp), %rax
movq %rax, 0xcea9(%rip)      # 0x14360
movq $0x0, -0x8(%rbp)
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_json.c
// Function: ensure
static char* ensure(printbuffer *p,int needed)
{
	char *newbuffer;int newsize;
	if (!p || !p->buffer) return 0;
	needed+=p->offset;
	if (needed<=p->length) return p->buffer+p->offset;

	newsize=pow2gt(needed);
	newbuffer=(char*)cJSON_malloc(newsize);
	if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}
	if (newbuffer) memcpy(newbuffer,p->buffer,p->length);
	cJSON_free(p->buffer);
	p->length=newsize;
	p->buffer=newbuffer;
	return newbuffer+p->offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7a40
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7a4d
movq $0x0, -0x8(%rbp)
jmp 0x7b2b
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x7a81
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b2b
movl -0x14(%rbp), %edi
callq 0x8bd0
movl %eax, -0x24(%rbp)
movq 0xc735(%rip), %rax      # 0x141c8
movslq -0x24(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7ad4
movq 0xc725(%rip), %rax      # 0x141d0
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7b2b
cmpq $0x0, -0x20(%rbp)
je 0x7af3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x21e0
movq 0xc6d6(%rip), %rax      # 0x141d0
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, -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/core/qq_listening.c
// Function: qq_add_listening_config
qq_int_t qq_add_listening_config(int type, int port,
    size_t pool_size, qq_connection_handler_pt handler)
{
    size_t                  size;
    qq_listening_config_t  *lcf;

    size = sizeof(qq_listening_config_t);
    lcf = qq_calloc(size);
    if (lcf == NULL) {
        qq_log_error(0, "qq_add_listening_config() malloc(%u) failed", size);
        return QQ_ERROR;
    }
    lcf->type = type;
    lcf->port = port;
    lcf->pool_size = pool_size;
    lcf->handler = handler;

    if (qq_cycle->current_listening_config == NULL) {
        qq_cycle->current_listening_config = lcf;
        qq_cycle->listening_config = lcf;
    }
    else {
        qq_cycle->current_listening_config->next = lcf;
        qq_cycle->current_listening_config = lcf;
    }
    qq_cycle->nlistening += 1;

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x20, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9143
movq -0x28(%rbp), %rdx
xorl %edi, %edi
leaq 0x686c(%rip), %rsi      # 0xf99b
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0x91eb
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0xb16a(%rip), %rax      # 0x142e0
movq (%rax), %rax
cmpq $0x0, 0x50(%rax)
jne 0x91a6
movq -0x30(%rbp), %rcx
leaq 0xb155(%rip), %rax      # 0x142e0
movq (%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rcx
leaq 0xb143(%rip), %rax      # 0x142e0
movq (%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x91cd
movq -0x30(%rbp), %rcx
leaq 0xb12f(%rip), %rax      # 0x142e0
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
leaq 0xb11a(%rip), %rax      # 0x142e0
movq (%rax), %rax
movq %rcx, 0x50(%rax)
leaq 0xb10c(%rip), %rax      # 0x142e0
movq (%rax), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
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/core/qq_listening.c
// Function: qq_close_listening_sockets
void
qq_close_listening_sockets(qq_cycle_t *cycle)
{
    qq_uint_t         i;
    qq_listening_t   *ls;
    qq_connection_t  *c;

    qq_log_debug("qq_close_listening_sockets()");

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

            if (c->pool != NULL && c->type == SOCK_DGRAM) {
                qq_destroy_pool(c->pool);
            }

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

        qq_log_debug("close listening %s #%d ", ls[i].addr_text, ls[i].fd);

        if (close(ls[i].fd) == -1) {
            qq_log_error(errno, "close socket %s failed", ls[i].addr_text);
        }


        ls[i].fd = (qq_socket_t) -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6193(%rip), %rdi      # 0xfba6
movb $0x0, %al
callq 0x9e70
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x9b45
movq -0x18(%rbp), %rax
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9ab9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9a83
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x3160
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x9aa5
movq -0x20(%rbp), %rax
cmpl $0x2, 0x48(%rax)
jne 0x9aa5
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2368
movq -0x20(%rbp), %rdi
callq 0x2ac0
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rsi
imulq $0x60, -0x10(%rbp), %rax
addq %rax, %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %edx
leaq 0x60e5(%rip), %rdi      # 0xfbc3
movb $0x0, %al
callq 0x9e70
movq -0x18(%rbp), %rax
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x2350
cmpl $-0x1, %eax
jne 0x9b22
callq 0x2030
movl (%rax), %edi
movq -0x18(%rbp), %rdx
imulq $0x60, -0x10(%rbp), %rax
addq %rax, %rdx
addq $0x18, %rdx
leaq 0x60c0(%rip), %rsi      # 0xfbdb
movb $0x0, %al
callq 0x9cc0
movq -0x18(%rbp), %rax
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9a2e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_log.c
// Function: qq_log_init
void
qq_log_init(qq_pid_t pid)
{
    char *p, *dir;
    char name[100];

    memset(qq_log.str, 0, QQ_MAX_LOG_STR);

    p = qq_log.str;
    qq_log.time_ptr = p;
    p += qq_log_time_value_len();

    qq_log.pid_ptr = p;
    sprintf(qq_log.pid_ptr, "   %10d   ", pid);
    p += qq_log_pid_value_len();

    qq_log.debug_desc_ptr = p;

    qq_log.errno_ptr = p;
    p += qq_log_errno_value_len();

    qq_log.err_desc_ptr = p;

    qq_log.err_prefix_len = qq_log_err_info_prefix_len();
    qq_log.debug_prefix_len = qq_log_debug_info_prefix_len();

    dir = (char *)get_current_dir_name();
    p = memcpy(name, dir, strlen(dir)) + strlen(dir);
    *p++ = '/';
    memcpy(p, QQ_ERR_LOG_FILE_NAME, strlen(QQ_ERR_LOG_FILE_NAME));

    qq_log.err_fd = qq_open_file(name, QQ_FILE_APPEND,
                                 QQ_FILE_CREATE_OR_OPEN,
                                 QQ_FILE_DEFAULT_ACCESS);
    if (qq_log.err_fd == -1) {
        qq_log.err_fd = STDERR_FILENO;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
leaq 0xa803(%rip), %rdi      # 0x14368
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2170
leaq 0xa7f0(%rip), %rax      # 0x14368
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xa8e1(%rip)      # 0x14468
movq -0x10(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xa8d2(%rip)      # 0x14470
movq 0xa8cb(%rip), %rdi      # 0x14470
movl -0x4(%rbp), %edx
leaq 0x6043(%rip), %rsi      # 0xfbf2
movb $0x0, %al
callq 0x2070
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xa8bb(%rip)      # 0x14488
movq -0x10(%rbp), %rax
movq %rax, 0xa8a0(%rip)      # 0x14478
movq -0x10(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xa891(%rip)      # 0x14480
movl $0x30, 0xa897(%rip)     # 0x14490
movl $0x23, 0xa891(%rip)     # 0x14494
callq 0x2330
movq %rax, -0x18(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
movq %rax, %rdx
callq 0x21e0
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x2f, (%rax)
movq -0x10(%rbp), %rax
movw 0x5f85(%rip), %cx       # 0xfbfd
movw %cx, (%rax)
movb 0x5f7e(%rip), %cl       # 0xfbff
movb %cl, 0x2(%rax)
leaq -0x80(%rbp), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x21b0
movl %eax, 0xa7f9(%rip)      # 0x14498
cmpl $-0x1, 0xa7f2(%rip)     # 0x14498
jne 0x9cb2
movl $0x2, 0xa7e6(%rip)      # 0x14498
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_log.c
// Function: qq_log_error_debug_core
static void
qq_log_error_debug_core(int type, qq_err_t err, const char *fmt, va_list args)
{
    int  len;

    memcpy(qq_log.time_ptr, qq_cached_err_log_time.data, qq_cached_err_log_time.len);

    if (type == QQ_LOG_ERROR) {
        sprintf(qq_log.errno_ptr, "%10d   ", err);
        len = vsprintf(qq_log.err_desc_ptr, fmt, args);
        len += qq_log.err_prefix_len;
        qq_log.str[len++] = '\n';
        write(qq_log.err_fd, qq_log.str, len);
    }
    else if (type == QQ_LOG_DEBUG){
        len = vsprintf(qq_log.debug_desc_ptr, fmt, args);
        len += qq_log.debug_prefix_len;
        qq_log.str[len++] = '\n';
        write(STDERR_FILENO, qq_log.str, len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq 0xa6eb(%rip), %rdi      # 0x14468
leaq 0xa95c(%rip), %rax      # 0x146e0
movq 0x8(%rax), %rsi
leaq 0xa951(%rip), %rax      # 0x146e0
movq (%rax), %rdx
callq 0x21e0
cmpl $0x1, -0x4(%rbp)
jne 0x9e09
movq 0xa6d4(%rip), %rdi      # 0x14478
movl -0x8(%rbp), %edx
leaq 0x5e47(%rip), %rsi      # 0xfbf5
movb $0x0, %al
callq 0x2070
movq 0xa6c4(%rip), %rdi      # 0x14480
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2110
movl %eax, -0x1c(%rbp)
movl 0xa6be(%rip), %eax      # 0x14490
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0xa57b(%rip), %rax      # 0x14368
movb $0xa, (%rax,%rcx)
movl 0xa6a1(%rip), %edi      # 0x14498
movslq -0x1c(%rbp), %rdx
leaq 0xa566(%rip), %rsi      # 0x14368
callq 0x20c0
jmp 0x9e62
cmpl $0x0, -0x4(%rbp)
jne 0x9e60
movq 0xa672(%rip), %rdi      # 0x14488
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2110
movl %eax, -0x1c(%rbp)
movl 0xa668(%rip), %eax      # 0x14494
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0xa521(%rip), %rax      # 0x14368
movb $0xa, (%rax,%rcx)
movslq -0x1c(%rbp), %rdx
movl $0x2, %edi
leaq 0xa50d(%rip), %rsi      # 0x14368
callq 0x20c0
jmp 0x9e62
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_log.c
// Function: qq_log_stderr
void
qq_log_stderr(const char *fmt, ...)
{
    u_char   *p, *last;
    va_list   args;
    u_char    errstr[QQ_MAX_LOG_STR];
    int       len;

    last = errstr + QQ_MAX_LOG_STR;

    p = qq_cpymem(errstr, "qq_sh_server: ", 14);

    va_start(args, fmt);
    len = vsnprintf(p, last - QQ_LINEFEED_SIZE - p, fmt, args);
    va_end(args);

    p += len;
    if (p > last - QQ_LINEFEED_SIZE) {
        p = last - QQ_LINEFEED_SIZE;
    }

    qq_linefeed(p);

    (void) write(STDERR_FILENO, errstr, p - errstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
testb %al, %al
je 0x9f57
movaps %xmm0, -0x1c0(%rbp)
movaps %xmm1, -0x1b0(%rbp)
movaps %xmm2, -0x1a0(%rbp)
movaps %xmm3, -0x190(%rbp)
movaps %xmm4, -0x180(%rbp)
movaps %xmm5, -0x170(%rbp)
movaps %xmm6, -0x160(%rbp)
movaps %xmm7, -0x150(%rbp)
movq %r9, -0x1c8(%rbp)
movq %r8, -0x1d0(%rbp)
movq %rcx, -0x1d8(%rbp)
movq %rdx, -0x1e0(%rbp)
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x130(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x18(%rbp)
leaq -0x130(%rbp), %rax
movq 0x5c64(%rip), %rcx      # 0xfc01
movq %rcx, -0x130(%rbp)
movl 0x5c5f(%rip), %ecx      # 0xfc09
movl %ecx, -0x128(%rbp)
movw 0x5c56(%rip), %cx       # 0xfc0d
movw %cx, -0x124(%rbp)
addq $0xe, %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x1f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $-0x1, %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2190
movl %eax, -0x134(%rbp)
leaq -0x30(%rbp), %rax
movl -0x134(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jbe 0xa045
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x130(%rbp), %rsi
subq %rsi, %rdx
movl $0x2, %edi
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_main.c
// Function: main
int
main(int argc, char *const *argv)
{
    if (qq_get_options(argc, argv) != QQ_OK) {
        return 1;
    }

    if (qq_show_help || qq_show_version) {
        qq_show_help_version_info();
        return 0;
    }

    if (!qq_debug_mode) {
        if (daemon(1, 0) != QQ_OK) {
            qq_log_stderr("daemon(0, 0) failed"); 
            return 1;
        }
    }

    qq_time_init();

    qq_log_init(getpid());

#if (QQ_HAVE_JSON)
    if (qq_cjson_init(QQ_JSON_POOL_SIZE) != 0) {
        qq_log_error(0, "qq_cjson_init() failed");
        return 1;
    }
#endif

    if (qq_cycle_init() == QQ_ERROR) {
        qq_log_error(0, "qq_cycle_init() failed");
        return 1;
    }

    if (qq_signals_init() != QQ_OK) {
        return 1;
    }

    qq_process_cycle(qq_cycle);

#if (QQ_HAVE_JSON)
    qq_cjson_done();
#endif

    qq_cycle_done();
 
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xa1b0
cmpq $0x0, %rax
je 0xa0b4
movl $0x1, -0x4(%rbp)
jmp 0xa1a1
cmpq $0x0, 0xa3e4(%rip)      # 0x144a0
jne 0xa0c8
cmpq $0x0, 0xa3e2(%rip)      # 0x144a8
je 0xa0d9
callq 0xa2e0
movl $0x0, -0x4(%rbp)
jmp 0xa1a1
cmpq $0x0, 0xa3cf(%rip)      # 0x144b0
jne 0xa110
movl $0x1, %edi
xorl %esi, %esi
callq 0x2240
cmpl $0x0, %eax
je 0xa10e
leaq 0x5b15(%rip), %rdi      # 0xfc10
movb $0x0, %al
callq 0x9f10
movl $0x1, -0x4(%rbp)
jmp 0xa1a1
jmp 0xa110
callq 0xd3c0
callq 0x22c0
movl %eax, %edi
callq 0x9b50
movl $0x10000, %edi          # imm = 0x10000
callq 0x5120
cmpl $0x0, %eax
je 0xa149
xorl %edi, %edi
leaq 0x5aeb(%rip), %rsi      # 0xfc24
movb $0x0, %al
callq 0x9cc0
movl $0x1, -0x4(%rbp)
jmp 0xa1a1
callq 0x2d40
cmpq $-0x1, %rax
jne 0xa16d
xorl %edi, %edi
leaq 0x5ade(%rip), %rsi      # 0xfc3b
movb $0x0, %al
callq 0x9cc0
movl $0x1, -0x4(%rbp)
jmp 0xa1a1
callq 0xbc80
cmpq $0x0, %rax
je 0xa181
movl $0x1, -0x4(%rbp)
jmp 0xa1a1
leaq 0xa158(%rip), %rax      # 0x142e0
movq (%rax), %rdi
callq 0xbd40
callq 0x51b0
callq 0x2ec0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_main.c
// Function: qq_get_options
static qq_int_t
qq_get_options(int argc, char *const *argv)
{
    u_char     *p;
    qq_int_t    i;

    for (i = 1; i < argc; i++) {
        p = (u_char *) argv[i];

        if (*p++ != '-') {
            qq_log_stderr("invalid option: %s", argv[i]);
            return QQ_ERROR;
        }

        while (*p) {
            switch (*p++) {
            case '?':
            case 'h':
                qq_show_help = 1;
                break;
            case 'v':
                qq_show_version = 1;
                break;
            case 'd':
                qq_debug_mode = 1;
                break;
            default:
                qq_log_stderr("invalid option: %c", *(p - 1));
                return QQ_ERROR;
            }
        }
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0xa2cd
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x2d, %eax
je 0xa226
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x5a40(%rip), %rdi      # 0xfc52
movb $0x0, %al
callq 0x9f10
movq $-0x1, -0x8(%rbp)
jmp 0xa2d5
jmp 0xa228
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa2ba
movq -0x20(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3f, %eax
je 0xa26e
jmp 0xa250
movl -0x2c(%rbp), %eax
subl $0x64, %eax
je 0xa288
jmp 0xa25a
movl -0x2c(%rbp), %eax
subl $0x68, %eax
je 0xa26e
jmp 0xa264
movl -0x2c(%rbp), %eax
subl $0x76, %eax
je 0xa27b
jmp 0xa295
movq $0x1, 0xa227(%rip) # 0x144a0
jmp 0xa2b5
movq $0x1, 0xa222(%rip) # 0x144a8
jmp 0xa2b5
movq $0x1, 0xa21d(%rip) # 0x144b0
jmp 0xa2b5
movq -0x20(%rbp), %rax
movzbl -0x1(%rax), %esi
leaq 0x59c1(%rip), %rdi      # 0xfc65
movb $0x0, %al
callq 0x9f10
movq $-0x1, -0x8(%rbp)
jmp 0xa2d5
jmp 0xa228
jmp 0xa2bc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa1c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_md5.c
// Function: MD5Final
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
    unsigned int index = 0, padlen = 0;
    unsigned char bits[8];

    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56)?(56-index):(120-index);
    MD5Encode(bits,context->count,8);
    MD5Update(context,PADDING,padlen);
    MD5Update(context,bits,8);
    MD5Encode(digest,context->state,16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0xb440
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xb44b
movl $0x78, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x8, %edx
callq 0xb4b0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x8d6f(%rip), %rsi      # 0x141e0
callq 0xa3b0
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0xa3b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl $0x10, %edx
callq 0xb4b0
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_mysql.c
// Function: qq_mysql_init
qq_int_t qq_mysql_init(void)
{
    qq_mysql = mysql_init(NULL);
    if (qq_mysql == NULL) {
        qq_log_error(0, "mysql_init() failed");
        return QQ_ERROR;
    }

    if (!mysql_real_connect(qq_mysql,
        QQ_MYSQL_HOST_NAME,
        QQ_MYSQL_USER_NAME,
        QQ_MYSQL_USER_PWD,
        QQ_MYSQL_DB_NAME,
        QQ_MYSQL_DB_PORT,
        NULL,
        0))
    {
        qq_log_error(0, "mysql_real_connect() failed");
        return QQ_ERROR;
    }

    if (mysql_query(qq_mysql, "set names utf8")) {
        qq_log_error(0, "mysql_query(set names utf8) failed");
        return QQ_ERROR;
    }
    

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x2100
movq %rax, 0x8e98(%rip)      # 0x144c0
cmpq $0x0, 0x8e90(%rip)      # 0x144c0
jne 0xb64f
xorl %edi, %edi
leaq 0x3ab9(%rip), %rsi      # 0xf0f4
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb6ea
movq 0x8e6a(%rip), %rdi      # 0x144c0
leaq 0x46c3(%rip), %rsi      # 0xfd20
leaq 0x46c6(%rip), %rdx      # 0xfd2a
leaq 0x46c4(%rip), %rcx      # 0xfd2f
leaq 0x46c6(%rip), %r8       # 0xfd38
movl $0xcea, %r9d            # imm = 0xCEA
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x2150
cmpq $0x0, %rax
jne 0xb6b0
xorl %edi, %edi
leaq 0x46a6(%rip), %rsi      # 0xfd45
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb6ea
movq 0x8e09(%rip), %rdi      # 0x144c0
leaq 0x46a3(%rip), %rsi      # 0xfd61
callq 0x21a0
cmpl $0x0, %eax
je 0xb6e2
xorl %edi, %edi
leaq 0x469f(%rip), %rsi      # 0xfd70
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb6ea
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %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_mysql.c
// Function: qq_mysql_wifi_device_select
MYSQL_RES *
qq_mysql_wifi_device_select(char *device_id)
{
    memset(qq_str, 0, 256);
    sprintf(qq_str, "SELECT app_id,app_type FROM wifi_device WHERE device_id='%s'", device_id);

    if (mysql_query(qq_mysql, qq_str)) {
        qq_log_error(0, "qq_mysql_wifi_device_select(%s) query failed", device_id);
        return NULL;
    }

    qq_res = mysql_store_result(qq_mysql);
    if (qq_res == NULL) {
        qq_log_error(0, "qq_mysql_wifi_device_select(%s) result failed", device_id);
        return NULL;
    }

    return qq_res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8d9d(%rip), %rdi      # 0x144d0
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq -0x10(%rbp), %rdx
leaq 0x8d86(%rip), %rdi      # 0x144d0
leaq 0x4642(%rip), %rsi      # 0xfd93
movb $0x0, %al
callq 0x2070
movq 0x8d61(%rip), %rdi      # 0x144c0
leaq 0x8d6a(%rip), %rsi      # 0x144d0
callq 0x21a0
cmpl $0x0, %eax
je 0xb78e
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq 0x4653(%rip), %rsi      # 0xfdd0
movb $0x0, %al
callq 0x9cc0
movq $0x0, -0x8(%rbp)
jmp 0xb7d4
movq 0x8d2b(%rip), %rdi      # 0x144c0
callq 0x2160
movq %rax, 0x8e2f(%rip)      # 0x145d0
cmpq $0x0, 0x8e27(%rip)      # 0x145d0
jne 0xb7c9
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq 0x4645(%rip), %rsi      # 0xfdfd
movb $0x0, %al
callq 0x9cc0
movq $0x0, -0x8(%rbp)
jmp 0xb7d4
movq 0x8e00(%rip), %rax      # 0x145d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_mysql.c
// Function: qq_mysql_wifi_device_insert_into
qq_int_t
qq_mysql_wifi_device_insert_into(char *device_id)
{
    memset(qq_str, 0, 256);
    sprintf(qq_str, "INSERT INTO wifi_device(device_id, app_id, app_type) VALUES ('%s', '%s', %d)",
        device_id, "\0", 0);

    if (mysql_query(qq_mysql, qq_str)) {
        qq_log_error(0, "qq_mysql_wifi_insert_into(device_id: %s) failed", device_id);
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8cdd(%rip), %rdi      # 0x144d0
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq -0x10(%rbp), %rdx
leaq 0x8cc6(%rip), %rdi      # 0x144d0
leaq 0x461a(%rip), %rsi      # 0xfe2b
leaq 0x4783(%rip), %rcx      # 0xff9b
xorl %r8d, %r8d
movb $0x0, %al
callq 0x2070
movq 0x8c97(%rip), %rdi      # 0x144c0
leaq 0x8ca0(%rip), %rsi      # 0x144d0
callq 0x21a0
cmpl $0x0, %eax
je 0xb858
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq 0x4631(%rip), %rsi      # 0xfe78
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb860
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/app/qq_mysql.c
// Function: qq_mysql_wifi_device_update
qq_int_t
qq_mysql_wifi_device_update(char *device_id, char *app_id, int app_type)
{
    memset(qq_str, 0, 256);
    sprintf(qq_str, "UPDATE wifi_device SET app_id='%s' and app_type=%d WHERE device_id='%s'",
        app_id, app_type, device_id);

    if (mysql_query(qq_mysql, qq_str)) {
        qq_log_error(0, "qq_mysql_wifi_device_update(device_id: %s, app_id: %s, app_type: %d) failed",
            device_id, app_id, app_type);
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq 0x8c46(%rip), %rdi      # 0x144d0
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %r8
leaq 0x8c28(%rip), %rdi      # 0x144d0
leaq 0x45f9(%rip), %rsi      # 0xfea8
movb $0x0, %al
callq 0x2070
movq 0x8c03(%rip), %rdi      # 0x144c0
leaq 0x8c0c(%rip), %rsi      # 0x144d0
callq 0x21a0
cmpl $0x0, %eax
je 0xb8f4
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
xorl %edi, %edi
leaq 0x460d(%rip), %rsi      # 0xfef0
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb8fc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %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_mysql.c
// Function: qq_mysql_wifi_device_delete
qq_int_t
qq_mysql_wifi_device_delete(char *device_id)
{
    memset(qq_str, 0, 256);
    sprintf(qq_str, "DELETE FROM wifi_device WHERE device_id='%s'", device_id);

    if (mysql_query(qq_mysql, qq_str)) {
        qq_log_error(0, "qq_mysql_wifi_device_delete(device_id: %s) failed", device_id);
        return QQ_ERROR;
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8bad(%rip), %rdi      # 0x144d0
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq -0x10(%rbp), %rdx
leaq 0x8b96(%rip), %rdi      # 0x144d0
leaq 0x45fb(%rip), %rsi      # 0xff3c
movb $0x0, %al
callq 0x2070
movq 0x8b71(%rip), %rdi      # 0x144c0
leaq 0x8b7a(%rip), %rsi      # 0x144d0
callq 0x21a0
cmpl $0x0, %eax
je 0xb97e
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq 0x45fc(%rip), %rsi      # 0xff69
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xb986
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_palloc.c
// Function: qq_create_pool
qq_pool_t *
qq_create_pool(size_t size)
{
    qq_pool_t  *p;

    p = qq_memalign(QQ_POOL_ALIGNMENT, size);
    if (p == NULL) {
        return NULL;
    }

    p->last = (u_char *) p + sizeof(qq_pool_t);
    p->end = (u_char *) p + size;

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x10, %edi
callq 0x2500
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xba5f
movq $0x0, -0x8(%rbp)
jmp 0xba86
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -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/core/qq_palloc.c
// Function: qq_palloc
void *
qq_palloc(qq_pool_t *pool, size_t size)
{
    u_char      *m;
    qq_pool_t   *p;

    p = pool;
    m = p->last;

    m = qq_align_ptr(m, QQ_ALIGNMENT);

    if ((size_t) (p->end - m) >= size) {
        p->last = m + size;
        return m;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq -0x18(%rbp), %rax
jb 0xbaed
movq -0x20(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbaf5
movq $0x0, -0x8(%rbp)
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_palloc.c
// Function: qq_pnalloc
void *
qq_pnalloc(qq_pool_t *pool, size_t size)
{
    u_char      *m;
    qq_pool_t   *p;

    p = pool;
    m = p->last;

    if ((size_t) (p->end - m) >= size) {
        p->last = m + size;
        return m;
    }
    
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq -0x18(%rbp), %rax
jb 0xbb4d
movq -0x20(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb55
movq $0x0, -0x8(%rbp)
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_palloc.c
// Function: qq_pcalloc
void *
qq_pcalloc(qq_pool_t *pool, size_t size)
{
    void *p;

    p = qq_palloc(pool, size);
    if (p) {
        memset(p, 0, 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 0xba90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbb97
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2170
movq -0x18(%rbp), %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_palloc.c
// Function: qq_pcnalloc
void *
qq_pcnalloc(qq_pool_t *pool, size_t size)
{
    void *p;

    p = qq_pnalloc(pool, size);
    if (p) {
        memset(p, 0, 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 0xbb00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbbe7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2170
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_process.c
// Function: qq_signal_handler
static void
qq_signal_handler(int signo)
{
    qq_log_debug("qq_signal_handler(%d)", signo);

    switch (signo) {
    case qq_signal_value(QQ_SHUTDOWN_SIGNAL):
        qq_quit = 1;
        qq_log_debug("shutting down");
        break;
    case qq_signal_value(QQ_TERMINATE_SIGNAL):
    case SIGINT:
        qq_terminate = 1;
        qq_log_debug("exiting");
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x43be(%rip), %rdi      # 0xffd3
xorl %eax, %eax
callq 0x9e70
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0xbc57
jmp 0xbc29
movl -0x8(%rbp), %eax
subl $0x3, %eax
je 0xbc3d
jmp 0xbc33
movl -0x8(%rbp), %eax
subl $0xf, %eax
je 0xbc57
jmp 0xbc6f
movl $0x1, 0x8995(%rip)      # 0x145dc
leaq 0x439b(%rip), %rdi      # 0xffe9
movb $0x0, %al
callq 0x9e70
jmp 0xbc6f
movl $0x1, 0x8977(%rip)      # 0x145d8
leaq 0x438f(%rip), %rdi      # 0xfff7
movb $0x0, %al
callq 0x9e70
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_process.c
// Function: qq_signals_init
qq_int_t
qq_signals_init(void)
{
    qq_signal_t       *sig;
    struct sigaction   sa;

    for (sig = signals; sig->signo != 0; sig++) {
        memset(&sa, 0, sizeof(struct sigaction));
        sa.sa_handler = sig->handler;
        sigemptyset(&sa.sa_mask);
        if (sigaction(sig->signo, &sa, NULL) == -1) {
            qq_log_error(errno, "sigaction(%s) failed", sig->signame);
            return QQ_ERROR;
        }
    }

    return QQ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x858e(%rip), %rax      # 0x14220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xbd2a
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2250
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2260
cmpl $-0x1, %eax
jne 0xbd17
callq 0x2030
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x42b8(%rip), %rsi      # 0xffbe
movb $0x0, %al
callq 0x9cc0
movq $-0x1, -0x8(%rbp)
jmp 0xbd32
jmp 0xbd19
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0xbc96
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/os/qq_process.c
// Function: qq_process_cycle
void
qq_process_cycle(qq_cycle_t *cycle)
{
    for (;;) {
        qq_events_process();

        if (qq_terminate || qq_quit) {
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3c90
cmpl $0x0, 0x8880(%rip)      # 0x145d8
jne 0xbd63
cmpl $0x0, 0x887b(%rip)      # 0x145dc
je 0xbd65
jmp 0xbd67
jmp 0xbd4c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qq-smart[P]qq_sh_server/core/qq_queue.c
// Function: qq_queue_middle
qq_queue_t *
qq_queue_middle(qq_queue_t *queue)
{
    qq_queue_t  *middle, *next;

    middle = qq_queue_head(queue);

    if (middle == qq_queue_last(queue)) {
        return middle;
    }

    next = qq_queue_head(queue);

    for ( ;; ) {
        middle = qq_queue_next(middle);

        next = qq_queue_next(next);

        if (next == qq_queue_last(queue)) {
            return middle;
        }

        next = qq_queue_next(next);

        if (next == qq_queue_last(queue)) {
            return middle;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xbd9b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbdfb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xbdd6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbdfb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xbdf9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbdfb
jmp 0xbda7
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_queue.c
// Function: qq_queue_sort
void
qq_queue_sort(qq_queue_t *queue,
    qq_int_t (*cmp)(const qq_queue_t *, const qq_queue_t *))
{
    qq_queue_t  *q, *prev, *next;

    q = qq_queue_head(queue);
    if (q == qq_queue_last(queue)) {
        return;
    }

    for (q = qq_queue_next(q); q != qq_queue_sentinel(queue); q = next) {
        prev = qq_queue_prev(q);
        next = qq_queue_next(q);

        qq_queue_remove(q);

        do {
            if (cmp(prev, q) <= 0) {
                break;
            }

            prev = qq_queue_prev(prev);

        } while (prev != qq_queue_sentinel(queue));

        qq_queue_insert_after(prev, q);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xbe3e
jmp 0xbf02
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xbf02
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpq $0x0, %rax
jg 0xbeaa
jmp 0xbebf
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0xbe94
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbe4a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)