LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_strerror
static const char*
soap_strerror(struct soap *soap)
{ register int err = soap->errnum;
  if (err)
  {
#ifndef WIN32
    return strerror(err);
#else
#ifndef UNDER_CE
    DWORD len;
    *soap->msgbuf = '\0';
    len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)soap->msgbuf, (DWORD)sizeof(soap->msgbuf), NULL);
#else
    DWORD i, len;
    *soap->msgbuf = '\0';
    len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
    for (i = 0; i <= len; i++)
    { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
        soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
      else
        soap->msgbuf[i] = '?';
    }
#endif
#endif
  }
  else
  { char *s = soap->msgbuf;
#ifndef WITH_LEAN
    int rt = soap->recv_timeout, st = soap->send_timeout;
    int ru = ' ', su = ' ';
#endif
    strcpy(s, "Operation interrupted or timed out");
#ifndef WITH_LEAN
    if (rt < 0)
    { rt = -rt;
      ru = 'u';
    }
    if (st < 0)
    { st = -st;
      su = 'u';
    }
    if (rt)
      sprintf(s + strlen(s), " (%d%cs receive delay)", rt, ru);
    if (st)
      sprintf(s + strlen(s), " (%d%cs send delay)", st, su);
#endif
  }
  return soap->msgbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1921c(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6d950
movl -0x14(%rbp), %edi
callq 0x33b0
movq %rax, -0x8(%rbp)
jmp 0x6da2e
movq -0x10(%rbp), %rax
addq $0x16138, %rax          # imm = 0x16138
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x20, -0x2c(%rbp)
movl $0x20, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xe6e9(%rip), %rsi      # 0x7c074
callq 0x3090
cmpl $0x0, -0x24(%rbp)
jge 0x6d9a5
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x75, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x6d9ba
xorl %eax, %eax
subl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x75, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6d9ec
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3100
movq -0x38(%rbp), %rdi
addq %rax, %rdi
movl -0x24(%rbp), %edx
movl -0x2c(%rbp), %ecx
leaq 0xe6b2(%rip), %rsi      # 0x7c097
movb $0x0, %al
callq 0x3370
cmpl $0x0, -0x28(%rbp)
je 0x6da1e
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
addq %rax, %rdi
movl -0x28(%rbp), %edx
movl -0x30(%rbp), %ecx
leaq 0xe697(%rip), %rsi      # 0x7c0ae
movb $0x0, %al
callq 0x3370
jmp 0x6da20
movq -0x10(%rbp), %rax
addq $0x16138, %rax          # imm = 0x16138
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: http_error
static const char*
http_error(struct soap *soap, int status)
{ register const char *msg = SOAP_STR_EOS;
#ifndef WITH_LEAN
  msg = soap_code_str(h_http_error_codes, status);
  if (!msg)
    msg = SOAP_STR_EOS;
#endif
  return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xca2b(%rip), %rax      # 0x7a481
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0x2111b(%rip), %rdi     # 0x8eb80
callq 0x500d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6da80
leaq 0xca05(%rip), %rax      # 0x7a481
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_send_empty_response
SOAP_FMAC2
soap_send_empty_response(struct soap *soap, int httpstatuscode)
{ register soap_mode m = soap->omode;
  soap->count = 0;
  if ((m & SOAP_IO) == SOAP_IO_CHUNK)
    soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
  if (soap_response(soap, httpstatuscode) || soap_end_send(soap))
  { soap->omode = m;
    return soap_closesock(soap);
  }
  soap->omode = m;
  return soap->error = SOAP_STOP; /* stops the server's response */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x6110(%rax)
movl -0x18(%rbp), %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0x6df73
movl -0x18(%rbp), %ecx
andl $-0x4, %ecx
orl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6cac0
cmpl $0x0, %eax
jne 0x6df92
movq -0x10(%rbp), %rdi
callq 0x5cde0
cmpl $0x0, %eax
je 0x6dfaa
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x55cf0
movl %eax, -0x4(%rbp)
jmp 0x6dfc9
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x3e8, 0x19214(%rax)   # imm = 0x3E8
movl $0x3e8, -0x4(%rbp)      # imm = 0x3E8
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_recv_empty_response
SOAP_FMAC2
soap_recv_empty_response(struct soap *soap)
{ if (!soap_begin_recv(soap))
    soap_end_recv(soap);
  else if (soap->error == SOAP_NO_DATA || soap->error == 202)
    soap->error = SOAP_OK;
  return soap_closesock(soap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a560
cmpl $0x0, %eax
jne 0x6e005
movq -0x8(%rbp), %rdi
callq 0x5d870
jmp 0x6e032
movq -0x8(%rbp), %rax
cmpl $0xe, 0x19214(%rax)
je 0x6e022
movq -0x8(%rbp), %rax
cmpl $0xca, 0x19214(%rax)
jne 0x6e030
movq -0x8(%rbp), %rax
movl $0x0, 0x19214(%rax)
jmp 0x6e032
movq -0x8(%rbp), %rdi
callq 0x55cf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_error
static int
soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
{ *soap_faultcode(soap) = faultcode;
  if (faultsubcodeQName)
    *soap_faultsubcode(soap) = faultsubcodeQName;
  *soap_faultstring(soap) = faultstring;
  if (faultdetailXML && *faultdetailXML)
  { register const char **s = soap_faultdetail(soap);
    if (s)
      *s = faultdetailXML;
  }
  return soap->error = soaperror;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3dd0
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x6e0a7
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3e20
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ed0
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x6e0f3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6e0f3
movq -0x8(%rbp), %rdi
callq 0x3f30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6e0f1
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6e0f3
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x19214(%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_copy_fault
static int
soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
{ char *r = NULL, *s = NULL, *t = NULL;
  if (faultsubcodeQName)
    r = soap_strdup(soap, faultsubcodeQName);
  if (faultstring)
    s = soap_strdup(soap, faultstring);
  if (faultdetailXML)
    t = soap_strdup(soap, faultdetailXML);
  return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e1dc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x538b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6e1f4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x538b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6e20c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x538b0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0xc, %r9d
callq 0x6e050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_print_fault_location
SOAP_FMAC2
soap_print_fault_location(struct soap *soap, FILE *fd)
{ 
#ifndef WITH_LEAN
  int i, j, c1, c2;
  if (soap->error && soap->error != SOAP_STOP && soap->bufidx <= soap->buflen && soap->buflen > 0 && soap->buflen <= SOAP_BUFLEN)
  { i = (int)soap->bufidx - 1;
    if (i <= 0)
      i = 0;
    c1 = soap->buf[i];
    soap->buf[i] = '\0';
    if ((int)soap->buflen >= i + 1024)
      j = i + 1023;
    else
      j = (int)soap->buflen - 1;
    c2 = soap->buf[j];
    soap->buf[j] = '\0';
    fprintf(fd, "%s%c\n<!-- ** HERE ** -->\n", soap->buf, c1);
    if (soap->bufidx < soap->buflen)
      fprintf(fd, "%s\n", soap->buf + soap->bufidx);
    soap->buf[i] = c1;
    soap->buf[j] = c2;
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x19214(%rax)
je 0x6e84a
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x19214(%rax)   # imm = 0x3E8
je 0x6e84a
movq -0x8(%rbp), %rax
movq 0x60f0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60f8(%rcx), %rax
ja 0x6e84a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60f8(%rax)
jbe 0x6e84a
movq -0x8(%rbp), %rax
cmpq $0x10000, 0x60f8(%rax) # imm = 0x10000
ja 0x6e84a
movq -0x8(%rbp), %rax
movq 0x60f0(%rax), %rax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x6e746
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl 0x6138(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, 0x6138(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x60f8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x400, %ecx            # imm = 0x400
cmpl %ecx, %eax
jl 0x6e78e
movl -0x14(%rbp), %eax
addl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x18(%rbp)
jmp 0x6e79f
movq -0x8(%rbp), %rax
movq 0x60f8(%rax), %rax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl 0x6138(%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, 0x6138(%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x6138, %rdx           # imm = 0x6138
movl -0x1c(%rbp), %ecx
leaq 0xce06(%rip), %rsi      # 0x7b5e1
movb $0x0, %al
callq 0x3220
movq -0x8(%rbp), %rax
movq 0x60f0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60f8(%rcx), %rax
jae 0x6e822
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x6138, %rdx           # imm = 0x6138
movq -0x8(%rbp), %rax
addq 0x60f0(%rax), %rdx
leaq 0xcd6d(%rip), %rsi      # 0x7b588
movb $0x0, %al
callq 0x3220
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, 0x6138(%rax,%rcx)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, 0x6138(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_register_plugin_arg
SOAP_FMAC2
soap_register_plugin_arg(struct soap *soap, int (*fcreate)(struct soap*, struct soap_plugin*, void*), void *arg)
{ register struct soap_plugin *p;
  register int r;
  if (!(p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin))))
    return soap->error = SOAP_EOM;
  p->id = NULL;
  p->data = NULL;
  p->fcopy = NULL;
  p->fdelete = NULL;
  r = fcreate(soap, p, arg);
  if (!r && p->fdelete)
  { p->next = soap->plugins;
    soap->plugins = p;
    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Registered '%s' plugin\n", p->id));
    return SOAP_OK;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not register plugin '%s': plugin returned error %d (or fdelete callback not set)\n", p->id?p->id:"?", r));
  SOAP_FREE(soap, p);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x28, %edi
callq 0x3290
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6e892
movq -0x10(%rbp), %rax
movl $0x14, 0x19214(%rax)
movl $0x14, -0x4(%rbp)
jmp 0x6e921
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6e912
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6e912
movq -0x10(%rbp), %rax
movq 0x5f50(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x5f50(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6e921
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_valid_mime_boundary
static int
soap_valid_mime_boundary(struct soap *soap)
{ register struct soap_multipart *content;
  register size_t k;
  if (soap->fmimeread)
    return SOAP_OK;
  k = strlen(soap->mime.boundary);
  for (content = soap->mime.first; content; content = content->next)
  { if (content->ptr && content->size >= k)
    { register const char *p = (const char*)content->ptr; 
      register size_t i;
      for (i = 0; i < content->size - k; i++, p++)
      { if (!strncmp(p, soap->mime.boundary, k))
          return SOAP_ERR;
      }
    }
  }
  return SOAP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60c0(%rax)
je 0x6e986
movl $0x0, -0x4(%rbp)
jmp 0x6ea53
movq -0x10(%rbp), %rax
movq 0x19288(%rax), %rdi
callq 0x3100
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x192a0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ea4c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6ea3a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jb 0x6ea3a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x6ea38
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x19288(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3080
cmpl $0x0, %eax
jne 0x6ea1c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ea53
jmp 0x6ea1e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6e9e1
jmp 0x6ea3a
jmp 0x6ea3c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6e9a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: http_send_header
static int
http_send_header(struct soap *soap, const char *s)
{ register const char *t;
  do
  { t = strchr(s, '\n'); /* disallow \n in HTTP headers */
    if (!t)
      t = s + strlen(s);
    if (soap_send_raw(soap, s, t - s))
      return soap->error;
    s = t + 1;
  } while (*t);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x3130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ec38
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x4eeb0
cmpl $0x0, %eax
je 0x6ec64
movq -0x10(%rbp), %rax
movl 0x19214(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ec80
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6ec00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/md5.c
// Function: MD5Update
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
    unsigned int i = 0,index = 0,partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;
    context->count[0] += inputlen << 3;
    if(context->count[0] < (inputlen << 3))
        context->count[1]++;
    context->count[1] += inputlen >> 29;

    if(inputlen >= partlen)
    {
        memcpy(&context->buffer[index],input,partlen);
        MD5Transform(context->state,context->buffer);
        for(i = partlen;i+64 <= inputlen;i+=64)
            MD5Transform(context->state,&input[i]);
        index = 0;
    }
    else
    {
        i = 0;
    }
    memcpy(&context->buffer[index],&input[i],inputlen-i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jae 0x6ed4d
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0x6edd2
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x3240
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x6ee10
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x40, %eax
cmpl -0x14(%rbp), %eax
ja 0x6edc9
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0x6ee10
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0x6ed9c
movl $0x0, -0x1c(%rbp)
jmp 0x6edd9
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/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 0x6fd70
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x6fd7b
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 0x6fde0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x1f48f(%rip), %rsi     # 0x8f230
callq 0x6ece0
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x6ece0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl $0x10, %edx
callq 0x6fde0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/md5.c
// Function: MD5Encode
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len)
    {
            output[j] = input[i] & 0xFF;
            output[j+1] = (input[i] >> 8) & 0xFF;
            output[j+2] = (input[i] >> 16) & 0xFF;
            output[j+3] = (input[i] >> 24) & 0xFF;
            i++;
            j+=4;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6fea4
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6fdfd
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/md5.c
// Function: MD5Decode
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len)
    {
            output[i] = (input[j]) |
                (input[j+1] << 8) |
                (input[j+2] << 16) |
                (input[j+3] << 24);
            i++;
            j+=4;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6ff3d
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x10, %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6fecd
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/md5.c
// Function: MD_5
char *MD_5(unsigned char *input)
{                   
    MD5_CTX md5;    
    MD5Init(&md5);  
    int i;          
    unsigned char decrypt[16];
    MD5Update(&md5,input,strlen((char *)input));
    MD5Final(&md5,decrypt);
    char buf[40] = {0};
    for (i = 0; i < 16; i++)
    {               
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%02x", decrypt[i]);
    }               
    return strdup(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6ec90
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3100
movq -0xb8(%rbp), %rsi
movl %eax, %edx
leaq -0x60(%rbp), %rdi
callq 0x6ece0
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6fd30
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3190
movl $0x0, -0x64(%rbp)
cmpl $0x10, -0x64(%rbp)
jge 0x70016
leaq -0xb0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3100
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3100
movq -0xc0(%rbp), %rdi
movl $0x28, %esi
subq %rax, %rsi
movslq -0x64(%rbp), %rax
movzbl -0x80(%rbp,%rax), %ecx
leaq 0xc0be(%rip), %rdx      # 0x7c0c2
movb $0x0, %al
callq 0x3150
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x6ffa5
leaq -0xb0(%rbp), %rdi
callq 0x33a0
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_client.c
// Function: addSGCRMTask
int addSGCRMTask(SGCRMTask *crm_task)
{
    if (crm_task == NULL)
    {
        return -1;
    }
    int ret = enqueueTask(&request_crm_queue, crm_task);
    printf("en ret = %d\n", ret);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7004c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x70077
movq -0x10(%rbp), %rsi
leaq 0x1f2e1(%rip), %rdi     # 0x8f338
callq 0x70710
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0xc05e(%rip), %rdi      # 0x7c0c7
movb $0x0, %al
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_client.c
// Function: monitorTaskAll
int monitorTaskAll()
{
	/* a function need to build calls */
	printf("nonitorajdfkl ajsdlk fjadsf \n");
    SGCRMTask *crm_task = NULL;
    crm_task = initSGCRMTask(crm_task);
    crm_task->search_string = strdup("(586) 4-4536");
    addSGCRMTask(crm_task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc045(%rip), %rdi      # 0x7c0d4
movb $0x0, %al
callq 0x3140
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x70b10
movq %rax, -0x10(%rbp)
leaq 0xc040(%rip), %rdi      # 0x7c0f2
callq 0x33a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x70030
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_client.c
// Function: executeRequest
int executeRequest(SGCRMInfoTask *info_task, SGCRMTask *crm_task)
{
	
	if (crm_task->search_result == NULL)
	{
		crm_task->search_result = initSGSearchResult(crm_task->search_result);
	}
	int res = searchAccounts(info_task->server_info, info_task->login_return->session_id, crm_task->search_string, crm_task->search_result);
	if (res == SOAP_OK)
	{
		if (crm_task->search_result->id == NULL)
		{
			printf("Not search ,continue need add\n");
			/* choose added to Account,Contacts,Leads */
			//continue;
		}
		printf("id = %s\nmodule = %s\n", crm_task->search_result->id, crm_task->search_result->module);
	}
	/*
    execute();
    search();
    cdr();
    addCall();
    callLinkUser();
    callLinkContact();*/
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x70113
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70e10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x77400
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x70183
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
jne 0x7015e
leaq 0xbfa8(%rip), %rdi      # 0x7c0ff
movb $0x0, %al
callq 0x3140
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xbfa2(%rip), %rdi      # 0x7c11e
movb $0x0, %al
callq 0x3140
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_client.c
// Function: crmClientStart
void crmClientStart()
{
    g_crm_task = 1;
    pthread_t crm_client_phread;
    pthread_attr_t crm_request_attr;
    pthread_attr_init(&crm_request_attr);
    pthread_attr_setstacksize((&crm_request_attr), CRM_STACK_SIZE);
    pthread_attr_setdetachstate((&crm_request_attr), PTHREAD_CREATE_DETACHED); //PTHREAD_CREATE_DETACHED
    //connectConfigDB(DB_CONF_CCRM);
    //connectConfigDB(DB_CDR_CCRM);
    //connectConfigDB(DB_STATUS_CCRM);
    pthread_create(&crm_client_phread, &crm_request_attr, (void *)crmClient, NULL);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x1, 0x1ef8e(%rip)     # 0x8f3a0
leaq -0x40(%rbp), %rdi
callq 0x31e0
leaq -0x40(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0x3420
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x3270
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x2b6(%rip), %rdx      # 0x70190
xorl %eax, %eax
movl %eax, %ecx
callq 0x3300
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: leave_number
char *leave_number(char *dest, char *src)
{
    if(src == NULL){
        return NULL;
    }
    char *p = dest;
    while(*src) {
        if (*src > '9' || *src <  '0') {
            src++;
        } else {
            *dest = *src;
            dest++;
            src++;
        }
    }
    *dest = '\0';
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x704ad
movq $0x0, -0x8(%rbp)
jmp 0x70519
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7050a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x704d6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jge 0x704e4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x70508
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x704b5
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: addPercent
char *addPercent(char *dest, char *src)
{
    if (src == NULL) {
        return NULL;
    }
    char *p = dest;
    while(*src) {
        *dest++ = '%';
        *dest++ = *src++;
    }
    *dest = '\0';
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7053d
movq $0x0, -0x8(%rbp)
jmp 0x70593
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x70584
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x25, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x70545
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: queueInitialize
void queueInitialize(Queue *queue)
{
    QueueNode *q_head_node = malloc(sizeof(QueueNode));
    if (q_head_node)
    {
        q_head_node->value = NULL;
        q_head_node->next = NULL;
    }

    queue->head = queue->end = q_head_node;
    queue->not_empty = 0;

    pthread_mutex_init(&queue->q_h_lock, NULL);
    pthread_mutex_init(&queue->q_t_lock, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x705d8
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33d0
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanQueue
void cleanQueue(Queue *queue)
{
    QueueNode *free_q_head_node = NULL;

    if (queue)
    {
        while(queue->head != NULL)
        {
            free_q_head_node = queue->head->next;
            if (queue->head->value != NULL)
            {
                cleanSGCRMTask(queue->head->value);
                queue->head->value = NULL;
            }

            free(queue->head);
            queue->head = free_q_head_node;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7069b
jmp 0x7063d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70699
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x70680
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x706b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7063d
jmp 0x7069b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGCRMTask
void cleanSGCRMTask(struct __sg_crm_task *crm_task)
{
    if (crm_task)
    {
        cleanSGSearchResult(crm_task->search_result);
        cleanSGCallItem(crm_task->call_item);
        cleanSGLinkReturn(crm_task->link_return);
    }
    SAFE_FREE(crm_task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x706ea
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70b60
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70c40
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x70dd0
cmpq $0x0, -0x8(%rbp)
je 0x70702
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: enqueueTask
ENQUEUE_RESULT enqueueTask(Queue *q, SGCRMTask *task)
{
    QueueNode* node = malloc(sizeof(QueueNode));
    if (node != NULL)
    {
        node->value = task;
        node->next = NULL;
    }

    pthread_mutex_lock(&q->q_t_lock);
    if (q->end != NULL)
    {
        q->end->next = node;
        q->end = node;
    }
    else
    {
        q->not_empty = 0;
        pthread_mutex_unlock(&q->q_t_lock);
        return ENQUEUE_FAILED_USER_DELETE;
    }
    q->not_empty = 1;
    pthread_mutex_unlock(&q->q_t_lock);

    return ENQUEUE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x3290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7074c
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x33f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70782
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x707a3
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3280
movl $0x1, -0x4(%rbp)
jmp 0x707c2
movq -0x10(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: dequeueTask
DEQUEUE_RESULT dequeueTask(Queue *q, SGCRMTask **pvalue)
{
    DEQUEUE_RESULT ret;
    QueueNode *next_node = NULL;

    pthread_mutex_lock(&q->q_h_lock);
    if (0 == q->not_empty)
    {
        pthread_mutex_unlock(&q->q_h_lock);
        return DEQUEUE_FAILED_EMPTY;
    }

    if(q->head != NULL)
    {
        next_node = q->head->next ;
    }

    if (next_node != NULL)
    {
        if (next_node == q->end)
        {
            pthread_mutex_lock(&q->q_t_lock);
            q->end = q->head;
            *pvalue = next_node->value;

            q->not_empty = 0;
			q->head->next = NULL;
            ret = DEQUEUE_SUCCESS_AND_EMPTY;
            pthread_mutex_unlock(&q->q_t_lock);
        }
        else
        {
            *pvalue = next_node->value;
            q->head->next = next_node->next ;
            ret = DEQUEUE_SUCCESS_AND_CONTINUE;
        }

        pthread_mutex_unlock(&q->q_h_lock);
        free(next_node);
    }
    else
    {
        pthread_mutex_unlock(&q->q_h_lock);
        ret = DEQUEUE_FAILED_EMPTY;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x33f0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x60(%rcx), %eax
jne 0x70819
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3280
movl $0x2, -0x4(%rbp)
jmp 0x708ff
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70832
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x708e5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x708a5
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x33f0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3280
jmp 0x708cd
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3280
movq -0x28(%rbp), %rdi
callq 0x3030
jmp 0x708f9
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3280
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGCRMInfoTask
struct __sg_crm_info_task *initSGCRMInfoTask(struct __sg_crm_info_task *crm_info_task)
{
    crm_info_task = (struct __sg_crm_info_task *)malloc(sizeof(struct __sg_crm_info_task));
    crm_info_task->login_return = initSGLoginReturn(crm_info_task->login_return);
    crm_info_task->server_info = initSGServerInfo(crm_info_task->server_info);
    return crm_info_task;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x70970
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x709b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGLoginReturn
struct __sg_login_return *initSGLoginReturn(struct __sg_login_return *login_return)
{
    login_return = (struct __sg_login_return *)malloc(sizeof(struct __sg_login_return));
    login_return->session_id = NULL;
    login_return->user_id = NULL;
    return login_return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGCRMInfoTask
void cleanSGCRMInfoTask(struct __sg_crm_info_task *crm_info_task)
{
    if (crm_info_task)
    {
        cleanSGLoginReturn(crm_info_task->login_return);
        cleanSGServerInfo(crm_info_task->server_info);
    }
    SAFE_FREE(crm_info_task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x70a0c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x70a30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70ab0
cmpq $0x0, -0x8(%rbp)
je 0x70a24
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGLoginReturn
void cleanSGLoginReturn(struct __sg_login_return *login_return)
{
    if (login_return) {
        SAFE_FREE(login_return->session_id);
        SAFE_FREE(login_return->user_id);
    }
    SAFE_FREE(login_return);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x70a8a
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70a64
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70a88
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x70a8a
cmpq $0x0, -0x8(%rbp)
je 0x70aa2
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGCRMTask
struct __sg_crm_task *initSGCRMTask(struct __sg_crm_task *crm_task)
{
    crm_task = (struct __sg_crm_task *)malloc(sizeof(struct __sg_crm_task));
    crm_task->search_result = NULL;
    crm_task->call_item = NULL;
    crm_task->link_return = NULL;
    return crm_task;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGSearchResult
void cleanSGSearchResult(struct __sg_search_result *search_result)
{
    printf("cleanSearchResult\n");
    if (search_result) {
		printf("youyou\n");
		if (search_result->id)
			printf("asdjfsadfasd\n");
		else
			printf("no nulllllll]n\n");
        SAFE_FREE(search_result->id);
        SAFE_FREE(search_result->module);
		printf("ono\n");
    }
    SAFE_FREE(search_result);
	printf("cleanSearchResult end\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb752(%rip), %rdi      # 0x7c2c5
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x8(%rbp)
je 0x70c0e
leaq 0xb74c(%rip), %rdi      # 0x7c2d8
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70bad
leaq 0xb73c(%rip), %rdi      # 0x7c2e0
movb $0x0, %al
callq 0x3140
jmp 0x70bbb
leaq 0xb73a(%rip), %rdi      # 0x7c2ee
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70bdc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70c00
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq 0xb6f7(%rip), %rdi      # 0x7c2fe
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x8(%rbp)
je 0x70c26
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
leaq 0xb6d6(%rip), %rdi      # 0x7c303
movb $0x0, %al
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGCallItem
void cleanSGCallItem(struct __sg_call_item* call_item)
{
    if (call_item) {
		printf("cleanCallItem\n");
        SAFE_FREE(call_item->name);
        SAFE_FREE(call_item->parent_type);
        SAFE_FREE(call_item->parent_id);
        SAFE_FREE(call_item->direction);
        SAFE_FREE(call_item->description);
        SAFE_FREE(call_item->duration_hours);
        SAFE_FREE(call_item->duration_minutes);
        SAFE_FREE(call_item->date_start);
        SAFE_FREE(call_item->assigned_user_id);
    }
    SAFE_FREE(call_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x70da8
leaq 0xb6bc(%rip), %rdi      # 0x7c31a
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70c86
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70caa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x70cce
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x70cf2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x70d16
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x70d3a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x70d5e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x70d82
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x70da6
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x70da8
cmpq $0x0, -0x8(%rbp)
je 0x70dc0
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGContactItem
struct __sg_contact_item *initSGContactItem(struct __sg_contact_item *contact_item)
{
	contact_item = (struct __sg_contact_item*)malloc(sizeof(struct __sg_contact_item));
	contact_item->title = NULL;
	contact_item->first_name = NULL;
	contact_item->last_name = NULL;
	contact_item->phone_home = NULL;
	contact_item->phone_work = NULL;
	contact_item->phone_mobile = NULL;
	contact_item->phone_other = NULL;
	contact_item->phone_fax = NULL;
	return contact_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)