LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_element_end_out
SOAP_FMAC2
soap_element_end_out(struct soap *soap, const char *tag)
{ const char *s;
  if (*tag == '-')
    return SOAP_OK;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag));
#ifdef WITH_DOM
  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
  { if (soap->dom->prnt)
      soap->dom = soap->dom->prnt;
    return SOAP_OK;
  }
#endif
#ifndef WITH_LEAN
  if (soap->mode & SOAP_XML_CANONICAL)
    soap_pop_namespace(soap);
  if (soap->mode & SOAP_XML_INDENT)
  { if (!soap->body)
    { if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
        return soap->error;
    }
    soap->body = 0;
  }
  if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')))
  { soap_pop_namespace(soap);
    tag = s + 1;
  }
#endif
  if (soap_send_raw(soap, "</", 2)
   || soap_send(soap, tag))
    return soap->error;
  soap->level--;	/* decrement level just before > */
  return soap_send_raw(soap, ">", 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
cmpb $0x2d, (%rsi)
je 0x3bb18
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
btl $0x10, %eax
jae 0x3ba70
movq %rbx, %rdi
callq 0x37ef0
movl 0x4(%rbx), %eax
btl $0xd, %eax
jae 0x3ba88
cmpw $0x0, 0x6106(%rbx)
je 0x3baf0
andw $0x0, 0x6106(%rbx)
testw %ax, %ax
jns 0x3baae
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
je 0x3baae
movq %rax, %r15
movq %rbx, %rdi
callq 0x37ef0
incq %r15
movq %r15, %r14
leaq 0x11b7b(%rip), %rsi     # 0x4d630
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x347c4
testl %eax, %eax
jne 0x3bb12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34a3f
testl %eax, %eax
jne 0x3bb12
decl 0x6108(%rbx)
leaq 0x11b4e(%rip), %rsi     # 0x4d62e
pushq $0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x347c4
movl 0x6108(%rbx), %eax
cmpl $0xa, %eax
pushq $0xa
popq %rdx
cmovbl %eax, %edx
leaq 0x11694(%rip), %rsi     # 0x4d19a
movq %rbx, %rdi
callq 0x347c4
testl %eax, %eax
je 0x3bb1e
movl 0x19214(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x4(%rbx), %eax
jmp 0x3ba80
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_new_multipart
static struct soap_multipart*
soap_new_multipart(struct soap *soap, struct soap_multipart **first, struct soap_multipart **last, char *ptr, size_t size)
{ struct soap_multipart *content;
  content = (struct soap_multipart*)soap_malloc(soap, sizeof(struct soap_multipart));
  if (content)
  { content->next = NULL;
    content->ptr = ptr;
    content->size = size;
    content->id = NULL;
    content->type = NULL;
    content->options = NULL;
    content->encoding = SOAP_MIME_NONE;
    content->location = NULL;
    content->description = NULL;
    if (!*first)
      *first = content;
    if (*last)
      (*last)->next = content;
    *last = content;
  }
  return content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x48
popq %rsi
callq 0x35f17
testq %rax, %rax
je 0x3bb79
andq $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x38(%rax)
cmpq $0x0, (%r14)
jne 0x3bb6b
movq %rax, (%r14)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x3bb76
movq %rax, (%rcx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_delete
SOAP_FMAC2
soap_delete(struct soap *soap, void *p)
{ register struct soap_clist **cp;
  if (soap_check_state(soap))
    return;
  cp = &soap->clist;
  if (p)
  { while (*cp)
    { if (p == (*cp)->ptr)
      { register struct soap_clist *q = *cp;
        *cp = q->next;
        if (q->fdelete(q))
        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
#ifdef SOAP_MEM_DEBUG
          fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
#endif
        }
        SOAP_FREE(soap, q);
        return;
      }
      cp = &(*cp)->next;
    }
    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: address not in list\n", p));
  }
  else
  { while (*cp)
    { register struct soap_clist *q = *cp;
      *cp = q->next;
      if (q->fdelete(q))
      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
#ifdef SOAP_MEM_DEBUG
        fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
#endif
      }
      SOAP_FREE(soap, q);
    }
  }
  soap->fault = NULL; /* this was possibly deallocated */
  soap->header = NULL; /* this was possibly deallocated */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3bd71
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpw $0x1, %ax
ja 0x3bd71
leaq 0x98(%rbx), %r14
testq %rsi, %rsi
je 0x3bd5f
movq %r14, %rax
movq (%r14), %r14
testq %r14, %r14
je 0x3bd67
cmpq %rsi, 0x8(%r14)
jne 0x3bd1f
movq (%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq *0x18(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
movq (%r15), %rax
movq %rax, (%r14)
movq %r15, %rdi
callq *0x18(%r15)
movq %r15, %rdi
callq 0x3030
movq (%r14), %r15
testq %r15, %r15
jne 0x3bd4a
xorps %xmm0, %xmm0
movups %xmm0, 0x5f30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_unlink
SOAP_FMAC2
soap_unlink(struct soap *soap, const void *p)
{ register char **q;
  register struct soap_clist **cp;
  if (!soap || !p)
    return;
  for (q = (char**)&soap->alist; *q; q = *(char***)q)
  { if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
    { *q = **(char***)q;
      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p));
#ifdef SOAP_MEM_DEBUG
      soap_track_unlink(soap, p);
#endif
      return;
    }
  }
  for (cp = &soap->clist; *cp; cp = &(*cp)->next)
  { if (p == (*cp)->ptr)
    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked class instance %p\n", p));
      q = (char**)*cp;
      *cp = (*cp)->next;
      SOAP_FREE(soap, q);
      return;
    }
  }
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x3be80
leaq 0xa0(%rdi), %rax
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x3be81
movq %rax, %rdx
subq 0x8(%rax), %rdx
cmpq %rsi, %rdx
jne 0x3be63
movq (%rax), %rax
movq %rax, (%rcx)
retq
addq $0x98, %rdi
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3be80
cmpq %rsi, 0x8(%rdi)
jne 0x3be88
movq (%rdi), %rcx
movq %rcx, (%rax)
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_lookup_type
SOAP_FMAC2
soap_lookup_type(struct soap *soap, const char *id)
{ register struct soap_ilist *ip;
  if (id && *id)
  { ip = soap_lookup(soap, id);
    if (ip)
    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup id='%s' type=%d\n", id, ip->type));
      return ip->type;
    }
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "lookup type id='%s' NOT FOUND! Need to get it from xsi:type\n", id));
  return 0;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3bebe
cmpb $0x0, (%rsi)
je 0x3bebe
callq 0x3bb85
testq %rax, %rax
je 0x3bebe
movl 0x8(%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_resolve_attachment
static void
soap_resolve_attachment(struct soap *soap, struct soap_multipart *content)
{ if (content->id)
  { register struct soap_xlist **xp = &soap->xlist;
    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving attachment data for id=%s\n", content->id));
    while (*xp)
    { register struct soap_xlist *xq = *xp;
      if (!soap_match_cid(soap, xq->id, content->id))
      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Found matching attachment %s for content id=%s\n", xq->id, content->id));
        *xp = xq->next;
        *xq->ptr = (unsigned char*)content->ptr;
        *xq->size = (int)content->size;
        *xq->type = (char*)content->type;
        if (content->options)
          *xq->options = (char*)content->options;
        else
          *xq->options = (char*)content->description;
        SOAP_FREE(soap, xq);
      }
      else
        xp = &(*xp)->next;
    }
  }
}

// Assembly:
cmpq $0x0, 0x18(%rsi)
je 0x3ce30
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x192b0(%rdi), %r12
movq (%r12), %r15
testq %r15, %r15
je 0x3ce25
movq 0x18(%r15), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x43b80
testl %eax, %eax
jne 0x3ce1f
movq (%r15), %rax
movq %rax, (%r12)
movq 0x8(%rbx), %rax
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movl 0x10(%rbx), %eax
movq 0x10(%r15), %rcx
movl %eax, (%rcx)
movq 0x20(%rbx), %rax
movq 0x20(%r15), %rcx
movq %rax, (%rcx)
movq 0x28(%rbx), %rax
testq %rax, %rax
jne 0x3ce0e
movq 0x40(%rbx), %rax
movq 0x28(%r15), %rcx
movq %rax, (%rcx)
movq %r15, %rdi
callq 0x3030
jmp 0x3cdbe
movq (%r12), %r12
jmp 0x3cdbe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_free_iht
static void
soap_free_iht(struct soap *soap)
{ register int i;
  register struct soap_ilist *ip = NULL, *p = NULL;
  register struct soap_flist *fp = NULL, *fq = NULL;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free ID hashtable\n"));
  for (i = 0; i < SOAP_IDHASH; i++)
  { for (ip = soap->iht[i]; ip; ip = p)
    { for (fp = ip->flist; fp; fp = fq)
      { fq = fp->next;
        SOAP_FREE(soap, fp);
      }
      p = ip->next;
      SOAP_FREE(soap, ip);
    }
    soap->iht[i] = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x7cf, %r15            # imm = 0x7CF
je 0x3ce89
movq 0xa8(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3ce7b
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x3ce6b
movq (%rdi), %r12
callq 0x3030
movq %r12, %rdi
jmp 0x3ce59
movq (%r14), %r12
movq %r14, %rdi
callq 0x3030
movq %r12, %r14
jmp 0x3ce50
andq $0x0, 0xa8(%rbx,%r15,8)
incq %r15
jmp 0x3ce3f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_init_logs
static void
soap_init_logs(struct soap *soap)
{ int i;
  for (i = 0; i < SOAP_MAXLOGS; i++)
  { soap->logfile[i] = NULL;
    soap->fdebug[i] = NULL;
  }
}

// Assembly:
pushq $-0x18
popq %rax
testq %rax, %rax
je 0x3d06f
andq $0x0, 0x192d0(%rdi,%rax)
andq $0x0, 0x192e8(%rdi,%rax)
addq $0x8, %rax
jmp 0x3d052
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_init_pht
static void
soap_init_pht(struct soap *soap)
{ register int i;
  soap->pblk = NULL;
  soap->pidx = 0;
  for (i = 0; i < (int)SOAP_PTRHASH; i++)
    soap->pht[i] = NULL;
}

// Assembly:
andq $0x0, 0x5f20(%rdi)
andw $0x0, 0x5f28(%rdi)
xorl %eax, %eax
cmpq $0x400, %rax            # imm = 0x400
je 0x3d0ae
andq $0x0, 0x3f20(%rdi,%rax,8)
incq %rax
jmp 0x3d098
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_end
SOAP_FMAC2
soap_end(struct soap *soap)
{ if (soap_check_state(soap))
    return;
  soap_free_temp(soap);
  soap_dealloc(soap, NULL);
  while (soap->clist)
  { register struct soap_clist *cp = soap->clist->next;
    SOAP_FREE(soap, soap->clist);
    soap->clist = cp;
  }
  soap_closesock(soap);
#ifdef SOAP_DEBUG
  soap_close_logfiles(soap);
#endif
#ifdef PALM
  palmNetLibClose();
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d594
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpw $0x1, %ax
ja 0x3d594
movq %rbx, %rdi
callq 0x38450
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3bc28
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x3d59c
movq (%rdi), %r14
callq 0x3030
movq %r14, 0x98(%rbx)
movq %r14, %rdi
jmp 0x3d57b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3858f
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_namespaces
SOAP_FMAC2
soap_set_namespaces(struct soap *soap, const struct Namespace *p)
{ register struct Namespace *ns = soap->local_namespaces;
  register struct soap_nlist *np, *nq, *nr;
  register unsigned int level = soap->level;
  soap->namespaces = p;
  soap->local_namespaces = NULL;
  soap_set_local_namespaces(soap);
  /* reverse the namespace list */
  np = soap->nlist;
  soap->nlist = NULL;
  if (np)
  { nq = np->next;
    np->next = NULL;
    while (nq)
    { nr = nq->next;
      nq->next = np;
      np = nq;
      nq = nr;
    }
  }
  /* then push on new stack */
  while (np)
  { register const char *s;
    soap->level = np->level; /* preserve element nesting level */
    s = np->ns;
    if (!s && np->index >= 0 && ns)
    { s = ns[np->index].out;
      if (!s)
        s = ns[np->index].ns;
    }
    if (s && soap_push_namespace(soap, np->id, s) == NULL)
      return soap->error;
    nq = np;
    np = np->next;
    SOAP_FREE(soap, nq);
  }
  if (ns)
  { register int i;
    for (i = 0; ns[i].id; i++)
    { if (ns[i].out)
      { SOAP_FREE(soap, ns[i].out);
        ns[i].out = NULL;
      }
    }
    SOAP_FREE(soap, ns);
  }
  soap->level = level; /* restore level */
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %r14
movl 0x6108(%rdi), %ebp
movq %rsi, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
callq 0x3b261
movq 0x88(%rbx), %r15
andq $0x0, 0x88(%rbx)
testq %r15, %r15
je 0x3d602
movq (%r15), %rax
andq $0x0, (%r15)
testq %rax, %rax
je 0x3d605
movq %rax, %rcx
movq (%rax), %rax
movq %r15, (%rcx)
movq %rcx, %r15
jmp 0x3d5ef
xorl %r15d, %r15d
testq %r15, %r15
je 0x3d672
movl 0x8(%r15), %eax
movl %eax, 0x6108(%rbx)
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x3d63e
leaq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x37d8d
testq %rax, %rax
je 0x3d699
movq (%r15), %r12
movq %r15, %rdi
callq 0x3030
movq %r12, %r15
jmp 0x3d605
testq %r14, %r14
setne %cl
movswq 0xc(%r15), %rax
testq %rax, %rax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x3d62e
shlq $0x5, %rax
movq 0x18(%r14,%rax), %rdx
testq %rdx, %rdx
jne 0x3d61d
addq %r14, %rax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
jne 0x3d61d
jmp 0x3d62e
testq %r14, %r14
je 0x3d6a9
leaq 0x18(%r14), %r15
cmpq $0x0, -0x18(%r15)
je 0x3d6a1
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3d693
callq 0x3030
andq $0x0, (%r15)
addq $0x20, %r15
jmp 0x3d67b
movl 0x19214(%rbx), %eax
jmp 0x3d6b1
movq %r14, %rdi
callq 0x3030
movl %ebp, 0x6108(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_strsearch
SOAP_FMAC1
const char *
SOAP_FMAC2
soap_strsearch(const char *big, const char *little)
{ if (little)
  { register size_t n = strlen(little);
    register const char *s = big;
    while (s) 
    { if (!strncmp(s, little, n) && (s[n] == '\0' || s[n] == ' '))
        return s;
      s = strchr(s, ' ');
      if (s)
        s++;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3d711
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3110
movq %rax, %r15
pushq $0x20
popq %rbp
testq %rbx, %rbx
je 0x3d711
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3080
testl %eax, %eax
jne 0x3d6fa
movzbl (%rbx,%r15), %eax
testb $-0x21, %al
je 0x3d713
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3130
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %rax, %rbx
jmp 0x3d6da
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_push_ns
static struct soap_nlist *
soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized)
{ register struct soap_nlist *np;
  size_t n, k;
  if (soap_strsearch(soap->c14nexclude, id))
    return NULL;
  if (!utilized)
  { for (np = soap->nlist; np; np = np->next)
    { if (!strcmp(np->id, id) && (!np->ns || !strcmp(np->ns, ns)))
        break;
    }
    if (np)
    { if ((np->level < soap->level || !np->ns) && np->index == 1)
        utilized = 1;
      else
        return NULL;
    }
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Adding namespace binding (level=%u) '%s' '%s' utilized=%d\n", soap->level, id, ns?ns:"(null)", utilized));
  n = strlen(id);
  if (ns)
    k = strlen(ns);
  else
    k = 0;
  np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k + 1);
  if (!np)
  { soap->error = SOAP_EOM;
    return NULL;
  }
  np->next = soap->nlist;
  soap->nlist = np;
  strcpy(np->id, id);
  if (ns)
    np->ns = strcpy(np->id + n + 1, ns);
  else
    np->ns = NULL;
  np->level = soap->level;
  np->index = utilized;
  return np;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x1b2f0(%rdi), %rdi
callq 0x3d6ba
testq %rax, %rax
jne 0x3ddb0
movw $0x1, %r13w
testw %bp, %bp
jne 0x3dd17
leaq 0x88(%rbx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x3dd14
leaq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x3210
testl %eax, %eax
jne 0x3dcc5
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x3dd06
movq %r14, %rsi
callq 0x3210
testl %eax, %eax
jne 0x3dcc5
movl 0x8(%r12), %eax
cmpl 0x6108(%rbx), %eax
jae 0x3ddb0
cmpw $0x1, 0xc(%r12)
je 0x3dd17
jmp 0x3ddb0
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3110
movq %rax, %r12
testq %r14, %r14
movl %r13d, 0x4(%rsp)
je 0x3dd36
movq %r14, %rdi
callq 0x3110
jmp 0x3dd38
xorl %eax, %eax
leaq (%r12,%rax), %rdi
addq $0x21, %rdi
callq 0x3290
testq %rax, %rax
je 0x3dd8a
movq %rax, %r13
movq 0x88(%rbx), %rax
movq %rax, (%r13)
movq %r13, 0x88(%rbx)
movq %r13, %rbp
addq $0x18, %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3090
testq %r14, %r14
je 0x3dd96
leaq (%r12,%rbp), %r15
incq %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3090
jmp 0x3dd99
movl $0x14, 0x19214(%rbx)
jmp 0x3ddb0
xorl %r15d, %r15d
movq %r15, 0x10(%r13)
movl 0x6108(%rbx), %eax
movl %eax, 0x8(%r13)
movl 0x4(%rsp), %eax
movw %ax, 0xc(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_attribute
SOAP_FMAC2
soap_attribute(struct soap *soap, const char *name, const char *value)
{ 
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attribute '%s'='%s'\n", name, value));
#ifdef WITH_DOM
  if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom)
  { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
    if (!a)
      return soap->error;
    a->next = soap->dom->atts;
    a->nstr = NULL;
    a->name = soap_strdup(soap, name);
    a->data = soap_strdup(soap, value);
    a->wide = NULL;
    a->soap = soap;
    soap->dom->atts = a;
    return SOAP_OK;
  }
#endif
#ifndef WITH_LEAN
  if (soap->mode & SOAP_XML_CANONICAL)
  { /* TODO: consider using this code to handle default namespace bindings
    if (!strncmp(name, "xmlns", 5) && (name[5] == ':' || name[5] == '\0'))
    { if (name[5] == ':')
        soap_push_ns(soap, name + 6, value, 0);
      else
        soap_push_ns(soap, "", value, 0);
    }
    */
    if (!strncmp(name, "xmlns:", 6))
      soap_push_ns(soap, name + 6, value, 0);
    else if (soap_set_attr(soap, name, value))
      return soap->error;
  }
  else
#endif
  { if (soap_send(soap, " ") || soap_send(soap, name))
      return soap->error;
    if (value)
      if (soap_send_raw(soap, "=\"", 2)
       || soap_string_out(soap, value, 1)
       || soap_send_raw(soap, "\"", 1))
        return soap->error;
  }
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, 0x6(%rdi)
jne 0x3de46
leaq 0xfb41(%rip), %rsi      # 0x4d91d
movq %rbx, %rdi
callq 0x34a3f
testl %eax, %eax
jne 0x3de6e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34a3f
testl %eax, %eax
jne 0x3de6e
xorl %ebp, %ebp
testq %r14, %r14
je 0x3de90
leaq 0xfcee(%rip), %rsi      # 0x4dafb
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x347c4
testl %eax, %eax
jne 0x3de6e
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e651
testl %eax, %eax
jne 0x3de6e
leaq 0xf9b9(%rip), %rsi      # 0x4d7ee
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x347c4
testl %eax, %eax
jne 0x3de6e
jmp 0x3de90
leaq 0xf81f(%rip), %rsi      # 0x4d66c
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x3080
testl %eax, %eax
je 0x3de76
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3e2d0
testl %eax, %eax
je 0x3de8e
movl 0x19214(%rbx), %ebp
jmp 0x3de90
addq $0x6, %r15
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3dc89
jmp 0x3de90
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_utilize_ns
static void
soap_utilize_ns(struct soap *soap, const char *tag, size_t n)
{ register struct soap_nlist *np = soap_lookup_ns(soap, tag, n);
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Utilizing namespace of '%s'\n", tag));
  if (np)
  { if (np->index == 0)
      soap_push_ns(soap, np->id, np->ns, 1);
  }
  else if (strncmp(tag, "xml", 3))
  { strncpy(soap->tmpbuf, tag, n);
    soap->tmpbuf[n] = '\0';
    soap_push_ns(soap, soap->tmpbuf, NULL, 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3d721
testq %rax, %rax
je 0x3decb
cmpw $0x0, 0xc(%rax)
je 0x3df0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x78, (%r15)
jne 0x3dedf
cmpb $0x6d, 0x1(%r15)
jne 0x3dedf
cmpb $0x6c, 0x2(%r15)
je 0x3debf
leaq 0x16538(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3070
movb $0x0, 0x16538(%rbx,%r14)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
jmp 0x3df1b
movq %rax, %rsi
addq $0x18, %rsi
movq 0x10(%rax), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3dc89
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_array_begin_out
SOAP_FMAC2
soap_array_begin_out(struct soap *soap, const char *tag, int id, const char *type, const char *offset)
{ if (!type || !*type)
    return soap_element_begin_out(soap, tag, id, NULL);
  if (soap_element(soap, tag, id, "SOAP-ENC:Array"))
    return soap->error;
  if (soap->version == 2)
  { const char *s;
    s = soap_strrchr(type, '[');
    if ((size_t)(s - type) < sizeof(soap->tmpbuf))
    { strncpy(soap->tmpbuf, type, s - type);
      soap->tmpbuf[s - type] = '\0';
      if (soap_attribute(soap, "SOAP-ENC:itemType", soap->tmpbuf))
        return soap->error;
      if (s && (soap_attribute(soap, "SOAP-ENC:arraySize", s + 1)))
        return soap->error;
    }
  }
  else
  { if (offset && soap_attribute(soap, "SOAP-ENC:offset", offset))
      return soap->error;
    if (soap_attribute(soap, "SOAP-ENC:arrayType", type))
      return soap->error;
  }
#ifndef WITH_LEAN
  if ((soap->mode & SOAP_XML_CANONICAL))
  { const char *s = strchr(type, ':');
    if (s)
      soap_utilize_ns(soap, type, s - type);
  }
#endif
  return soap_element_start_end_out(soap, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
je 0x3e1d7
movq %rcx, %r14
cmpb $0x0, (%rcx)
je 0x3e1d7
movq %r8, %r15
leaq 0xe506(%rip), %rcx      # 0x4c6c1
movq %rbx, %rdi
callq 0x3d76d
testl %eax, %eax
je 0x3e1ea
movl 0x19214(%rbx), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3b9c9
cmpw $0x2, 0x2(%rbx)
jne 0x3e25d
pushq $0x5b
popq %rsi
movq %r14, %rdi
callq 0x3160
movq %rax, %r12
subq %r14, %r12
cmpq $0x3ff, %r12            # imm = 0x3FF
ja 0x3e296
movq %rax, %r15
leaq 0x16538(%rbx), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3070
movb $0x0, 0x16538(%rbx,%r12)
leaq 0xf3ae(%rip), %rsi      # 0x4d5e5
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3ddbf
testl %eax, %eax
jne 0x3e1c7
testq %r15, %r15
je 0x3e296
incq %r15
leaq 0xf3a2(%rip), %rsi      # 0x4d5f7
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x3e289
testq %r15, %r15
je 0x3e27c
leaq 0xf3a1(%rip), %rsi      # 0x4d60a
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3ddbf
testl %eax, %eax
jne 0x3e1c7
leaq 0xf397(%rip), %rsi      # 0x4d61a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3ddbf
testl %eax, %eax
jne 0x3e1c7
testb $0x1, 0x6(%rbx)
je 0x3e2bd
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
je 0x3e2bd
subq %r14, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3de9d
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3df2b
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_element_ref
SOAP_FMAC2
soap_element_ref(struct soap *soap, const char *tag, int id, int href)
{ register int n = 0;
  const char *s = "href";
  if (soap->version == 2)
  { s = "SOAP-ENC:ref";
    n = 1;
  }
  sprintf(soap->href, "#_%d", href);
  return soap_element_href(soap, tag, id, s, soap->href + n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
cmpw $0x2, 0x2(%rdi)
sete %r13b
leaq 0xedb9(%rip), %rax      # 0x4d633
leaq 0xec92(%rip), %r12      # 0x4d513
cmoveq %rax, %r12
addq $0x17138, %rdi          # imm = 0x17138
leaq 0xedad(%rip), %rsi      # 0x4d640
movl %ecx, %edx
xorl %eax, %eax
callq 0x3370
leaq (%r15,%r13), %r8
addq $0x17138, %r8           # imm = 0x17138
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3b9f0
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_element_null
SOAP_FMAC2
soap_element_null(struct soap *soap, const char *tag, int id, const char *type)
{ struct soap_attribute *tp;
  for (tp = soap->attributes; tp; tp = tp->next)
    if (tp->visible)
      break;
  if (tp || (soap->version == 2 && soap->position > 0) || id > 0 || (soap->mode & SOAP_XML_NIL))
  { if (soap_element(soap, tag, id, type))
      return soap->error;
    if (!tp && soap_attribute(soap, "xsi:nil", "true"))
      return soap->error;
    return soap_element_start_end_out(soap, tag);
  }
  soap->null = 1;
  soap->position = 0;
  soap->mustUnderstand = 0;
  return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18580(%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x3e8e4
cmpw $0x0, 0x20(%r15)
je 0x3e8d2
jmp 0x3e91b
cmpw $0x2, 0x2(%rbx)
jne 0x3e8fb
testl %edx, %edx
jg 0x3e91b
cmpw $0x0, 0x1853a(%rbx)
jle 0x3e8ff
jmp 0x3e91b
testl %edx, %edx
jg 0x3e91b
testb $0x8, 0x6(%rbx)
jne 0x3e91b
andw $0x0, 0x1853a(%rbx)
movl $0x10000, 0x1858a(%rbx) # imm = 0x10000
xorl %eax, %eax
jmp 0x3e930
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d76d
testl %eax, %eax
je 0x3e936
movl 0x19214(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
testq %r15, %r15
je 0x3e94b
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3df2b
leaq 0xecf3(%rip), %rsi      # 0x4d645
leaq 0xdf0e(%rip), %rdx      # 0x4c867
movq %rbx, %rdi
callq 0x3ddbf
testl %eax, %eax
jne 0x3e92a
jmp 0x3e93b
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_element_result
SOAP_FMAC2
soap_element_result(struct soap *soap, const char *tag)
{ if (soap->version == 2 && soap->encodingStyle)
  { if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
     || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc)
     || soap_element_start_end_out(soap, NULL)
     || soap_string_out(soap, tag, 0)
     || soap_element_end_out(soap, "SOAP-RPC:result"))
      return soap->error;
  }
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
cmpw $0x2, 0x2(%rdi)
jne 0x3e9ec
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
je 0x3e9ec
movq %rsi, %r14
leaq 0xecc5(%rip), %rsi      # 0x4d64d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3d76d
testl %eax, %eax
jne 0x3e9e6
leaq 0xecbe(%rip), %rsi      # 0x4d65d
leaq 0xe80a(%rip), %rdx      # 0x4d1b0
movq %rbx, %rdi
callq 0x3ddbf
testl %eax, %eax
jne 0x3e9e6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3df2b
testl %eax, %eax
jne 0x3e9e6
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3e651
testl %eax, %eax
jne 0x3e9e6
leaq 0xec73(%rip), %rsi      # 0x4d64d
movq %rbx, %rdi
callq 0x3ba46
testl %eax, %eax
je 0x3e9ec
movl 0x19214(%rbx), %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_attr_value
SOAP_FMAC1
const char *
SOAP_FMAC2
soap_attr_value(struct soap *soap, const char *name, int flag)
{ register struct soap_attribute *tp;
  if (*name == '-')
    return SOAP_STR_EOS;
  for (tp = soap->attributes; tp; tp = tp->next)
  { if (tp->visible && !soap_match_tag(soap, tp->name, name))
      break;
  }
  if (tp)
  { if (flag == 2 && (soap->mode & SOAP_XML_STRICT))
      soap->error = SOAP_PROHIBITED;
    else
      return tp->value;
  }
  else if (flag == 1 && (soap->mode & SOAP_XML_STRICT))
    soap->error = SOAP_REQUIRED;
  else
    soap->error = SOAP_OK;
  return NULL;
}

// Assembly:
cmpb $0x2d, (%rsi)
jne 0x3ebd6
leaq 0xe58c(%rip), %rax      # 0x4d161
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18580(%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x3ec20
cmpw $0x0, 0x20(%r15)
je 0x3ebec
leaq 0x22(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x380f0
testl %eax, %eax
jne 0x3ebec
cmpl $0x2, %ebp
jne 0x3ec1a
testb $0x10, 0x5(%rbx)
jne 0x3ec40
movq 0x8(%r15), %rax
jmp 0x3ec4c
cmpl $0x1, %ebp
jne 0x3ec2b
testb $0x10, 0x5(%rbx)
jne 0x3ec34
andl $0x0, 0x19214(%rbx)
jmp 0x3ec4a
movl $0x2a, 0x19214(%rbx)
jmp 0x3ec4a
movl $0x2b, 0x19214(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_getattrval
static int
soap_getattrval(struct soap *soap, char *s, size_t n, soap_wchar d)
{ register size_t i;
  for (i = 0; i < n; i++)
  { register soap_wchar c = soap_get(soap);
    switch (c)
    {
    case SOAP_TT:
      *s++ = '<';
      soap_unget(soap, '/');
      break;
    case SOAP_LT:
      *s++ = '<';
      break;
    case SOAP_GT:
      if (d == ' ')
      { soap_unget(soap, c);
        *s = '\0';
        return SOAP_OK;
      }
      *s++ = '>';
      break;
    case SOAP_QT:
      if (c == d)
      { *s = '\0';
        return SOAP_OK;
      }
      *s++ = '"';
      break;
    case SOAP_AP:
      if (c == d)
      { *s = '\0';
        return SOAP_OK;
      }
      *s++ = '\'';
      break;
    case '\t':
    case '\n':
    case '\r':
    case ' ':
    case '/':
      if (d == ' ')
      { soap_unget(soap, c);
        *s = '\0';
        return SOAP_OK;
      }
    default:
      if ((int)c == EOF)
        return soap->error = SOAP_EOF;
      *s++ = (char)c;
    }
  }
  return soap->error = SOAP_EOM;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0xe31c(%rip), %r13      # 0x4cfa0
cmpq %r12, %r15
je 0x3ecf8
movq %r14, %rdi
callq 0x352a1
leal 0x6(%rax), %ecx
cmpl $0x13, %ecx
ja 0x3ecaf
movslq (%r13,%rcx,4), %rcx
addq %r13, %rcx
jmpq *%rcx
cmpl $-0x6, %ebp
je 0x3ed0f
movb $0x27, (%rbx,%r12)
jmp 0x3ecc2
cmpl $0x20, %eax
je 0x3ecb9
cmpl $0x2f, %eax
jne 0x3ecbe
cmpl $0x20, %ebp
je 0x3ed08
movb %al, (%rbx,%r12)
incq %r12
jmp 0x3ec84
movb $0x3c, (%rbx,%r12)
jmp 0x3ecc2
cmpl $-0x5, %ebp
je 0x3ed0f
movb $0x22, (%rbx,%r12)
jmp 0x3ecc2
cmpl $0x20, %ebp
je 0x3ed31
movb $0x3e, (%rbx,%r12)
jmp 0x3ecc2
movb $0x3c, (%rbx,%r12)
movl $0x2f, 0x6100(%r14)
jmp 0x3ecc2
movl $0x14, 0x19214(%r14)
pushq $0x14
popq %rax
jmp 0x3ed16
movl %eax, 0x6100(%r14)
movb $0x0, (%rbx,%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
orl $-0x1, 0x19214(%r14)
pushq $-0x1
jmp 0x3ed05
movl $0xfffffffc, 0x6100(%r14) # imm = 0xFFFFFFFC
jmp 0x3ed0f
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_revert
SOAP_FMAC2
soap_revert(struct soap *soap)
{ if (!soap->peeked)
  { soap->peeked = 1;
    if (soap->body)
      soap->level--;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reverting last element (level=%u)\n", soap->level));
}

// Assembly:
cmpw $0x0, 0x18594(%rdi)
je 0x3ed55
retq
movw $0x1, 0x18594(%rdi)
cmpw $0x0, 0x6106(%rdi)
je 0x3ed54
decl 0x6108(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_wstring_out
SOAP_FMAC2
soap_wstring_out(struct soap *soap, const wchar_t *s, int flag)
{ const char *t;
  char tmp;
  register soap_wchar c;
#ifdef WITH_DOM
  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
  { wchar_t *r = (wchar_t*)s;
    int n = 1;
    while (*r++)
      n++;
    soap->dom->wide = r = (wchar_t*)soap_malloc(soap, n * sizeof(wchar_t));
    while (n--)
      *r++ = *s++;
    return SOAP_OK;
  }
#endif
  while ((c = *s++))
  { switch (c)
    { 
    case 0x09:
      if (flag)
        t = "&#x9;";
      else
        t = "\t";
      break;
    case 0x0A:
      if (flag || !(soap->mode & SOAP_XML_CANONICAL))
        t = "&#xA;";
      else
        t = "\n";
      break;
    case 0x0D:
      t = "&#xD;";
      break;
    case '&':
      t = "&amp;";
      break;
    case '<':
      t = "&lt;";
      break;
    case '>':
      if (flag)
        t = ">";
      else
        t = "&gt;";
      break;
    case '"':
      if (flag)
        t = "&quot;";
      else
        t = "\"";
      break;
    default:
      if (c >= 0x20 && c < 0x80)
      { tmp = (char)c;
        if (soap_send_raw(soap, &tmp, 1))
          return soap->error;
      }
      else if (soap_pututf8(soap, (unsigned long)c))
        return soap->error;
      continue;
    }
    if (soap_send(soap, t))
      return soap->error;
  }
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edx, 0x4(%rsp)
testl %edx, %edx
leaq 0xddef(%rip), %rax      # 0x4d7ee
leaq 0xdd18(%rip), %rbp      # 0x4d71e
cmoveq %rax, %rbp
leaq 0xdd08(%rip), %rax      # 0x4d719
leaq 0xdc16(%rip), %r12      # 0x4d62e
cmoveq %rax, %r12
leaq 0xdd0e(%rip), %rax      # 0x4d731
leaq 0xdcd2(%rip), %r13      # 0x4d6fc
cmoveq %rax, %r13
movq %rdi, %r15
leaq 0xdcd0(%rip), %rbx      # 0x4d708
movslq (%r14), %rsi
addq $0x4, %r14
movq %r13, %rax
cmpq $0x9, %rsi
je 0x3facd
cmpl $0xa, %esi
je 0x3faa8
movq %rbx, %rax
cmpl $0xd, %esi
je 0x3facd
movq %rbp, %rax
cmpl $0x22, %esi
je 0x3facd
cmpl $0x26, %esi
je 0x3fa9f
cmpl $0x3c, %esi
je 0x3fa96
movq %r12, %rax
cmpl $0x3e, %esi
je 0x3facd
testl %esi, %esi
je 0x3faf3
leal -0x20(%rsi), %eax
cmpl $0x5f, %eax
ja 0x3fae2
movb %sil, 0x3(%rsp)
movq %r15, %rdi
leaq 0x3(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x347c4
jmp 0x3fad8
leaq 0xdc77(%rip), %rax      # 0x4d714
jmp 0x3facd
leaq 0xdc68(%rip), %rax      # 0x4d70e
jmp 0x3facd
leaq 0xdc53(%rip), %rax      # 0x4d702
cmpl $0x0, 0x4(%rsp)
jne 0x3facd
testb $0x1, 0x6(%r15)
leaq 0xda61(%rip), %rax      # 0x4d523
leaq 0xdc39(%rip), %rcx      # 0x4d702
cmoveq %rcx, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x34a3f
testl %eax, %eax
je 0x3fa38
jmp 0x3faec
movq %r15, %rdi
callq 0x35941
jmp 0x3fad8
movl 0x19214(%r15), %esi
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outint
SOAP_FMAC2
soap_outint(struct soap *soap, const char *tag, int id, const int *p, const char *type, int n)
{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
   || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x3b587
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x3b9c9
testl %eax, %eax
jne 0x3ff0d
movslq (%r15), %rsi
movq %r14, %rdi
callq 0x3fe9b
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3e651
testl %eax, %eax
je 0x3ff20
movl 0x19214(%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ba46
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_s2int
SOAP_FMAC2
soap_s2int(struct soap *soap, const char *s, int *p)
{ if (s)
  { char *r;
#ifndef WITH_NOIO
#ifndef WITH_LEAN
    soap_reset_errno;
#endif
#endif
    *p = (int)soap_strtol(s, &r, 10);
    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
#ifndef WITH_NOIO
#ifndef WITH_LEAN
     || soap_errno == SOAP_ERANGE
#endif
#endif
    )
      soap->error = SOAP_TYPE;
  }
  return soap->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3ff97
movq %rdx, %r12
movq %rsi, %r15
callq 0x3060
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3230
movl %eax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x3ff82
testb $0x10, 0x5(%rbx)
jne 0x3ff8d
cmpb $0x0, (%rax)
jne 0x3ff8d
cmpl $0x22, (%r14)
jne 0x3ff97
movl $0x4, 0x19214(%rbx)
movl 0x19214(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_inint
SOAP_FMAC1
int *
SOAP_FMAC2
soap_inint(struct soap *soap, const char *tag, int *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":int")
   && soap_match_tag(soap, soap->type, ":short")
   && soap_match_tag(soap, soap->type, ":byte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(int), 0, NULL);
  else if (p)
  { if (soap_s2int(soap, soap_value(soap), p))
      return NULL;
  }
  if (soap->body && soap_element_end_in(soap, tag))
    return NULL;
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36f8a
testl %eax, %eax
jne 0x400f8
cmpb $0x0, 0x17538(%rbx)
je 0x40057
leaq 0x17538(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x380f0
testl %eax, %eax
je 0x40057
leaq 0xbbb6(%rip), %rdx      # 0x4bbbb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40057
leaq 0xd718(%rip), %rdx      # 0x4d733
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40057
leaq 0xbb81(%rip), %rdx      # 0x4bbb2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40057
movl $0x4, 0x19214(%rbx)
movq %rbx, %rdi
callq 0x3ed4a
jmp 0x400f5
leaq 0x16d38(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x4
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x3c1b5
movq %rax, %r15
cmpb $0x0, 0x17138(%rbx)
je 0x400d6
leaq 0x17138(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x4, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3c06d
movq %rax, %r15
cmpw $0x0, 0x6106(%rbx)
je 0x400f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3713c
testl %eax, %eax
jne 0x400f5
jmp 0x400f8
testq %r15, %r15
je 0x4010a
movq %rbx, %rdi
callq 0x4010f
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3ff36
testl %eax, %eax
je 0x400bb
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x400bb
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_value
SOAP_FMAC1
const char *
SOAP_FMAC2
soap_value(struct soap *soap)
{ register size_t i;
  register soap_wchar c = 0;
  register char *s = soap->tmpbuf;
  if (!soap->body)
    return SOAP_STR_EOS;
  do c = soap_get(soap);
  while (soap_blank(c));
  for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++)
  { if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
      break;
    *s++ = (char)c;
    c = soap_get(soap);
  }
  for (s--; i > 0; i--, s--)
  { if (!soap_blank(*s))
      break;
  }
  s[1] = '\0';
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf));
  if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
    soap_unget(soap, c);
  else if (soap->mode & SOAP_XML_STRICT)
  { soap->error = SOAP_LENGTH;
    return NULL;
  }
#ifdef WITH_DOM
  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    soap->dom->data = soap_strdup(soap, soap->tmpbuf);
#endif
  return soap->tmpbuf; /* return non-null pointer */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpw $0x0, 0x6106(%rdi)
je 0x40185
movq %rdi, %r14
leaq 0x16538(%rdi), %rbx
movq %r14, %rdi
callq 0x352a1
cmpl $0x21, %eax
jb 0x4012b
leaq 0x16539(%r14), %r12
xorl %r15d, %r15d
cmpq $0x3fe, %r15            # imm = 0x3FE
ja 0x40165
cmpl $-0x3, %eax
jae 0x40165
movb %al, 0x16538(%r14,%r15)
movq %r14, %rdi
callq 0x352a1
incq %r15
jmp 0x40142
addq %r15, %r12
negq %r15
testq %r15, %r15
je 0x4018e
incq %r15
leaq -0x1(%r12), %rcx
cmpb $0x21, -0x2(%r12)
movq %rcx, %r12
jb 0x4016b
jmp 0x40191
leaq 0xcfd5(%rip), %rbx      # 0x4d161
jmp 0x401b6
movq %rbx, %rcx
movb $0x0, (%rcx)
cmpl $-0x3, %eax
jb 0x401a2
movl %eax, 0x6100(%r14)
jmp 0x401b6
testb $0x10, 0x5(%r14)
je 0x401b6
movl $0x2d, 0x19214(%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outlong
SOAP_FMAC2
soap_outlong(struct soap *soap, const char *tag, int id, const long *p, const char *type, int n)
{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
   || soap_string_out(soap, soap_long2s(soap, *p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x3b587
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x3b9c9
testl %eax, %eax
jne 0x40216
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3fe9b
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3e651
testl %eax, %eax
je 0x40229
movl 0x19214(%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ba46
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_s2long
SOAP_FMAC2
soap_s2long(struct soap *soap, const char *s, long *p)
{ if (s)
  { char *r;
#ifndef WITH_NOIO
#ifndef WITH_LEAN
    soap_reset_errno;
#endif
#endif
    *p = soap_strtol(s, &r, 10);
    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
#ifndef WITH_NOIO
#ifndef WITH_LEAN
     || soap_errno == SOAP_ERANGE
#endif
#endif
    )
      soap->error = SOAP_TYPE;
  }
  return soap->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x402a0
movq %rdx, %r12
movq %rsi, %r15
callq 0x3060
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3230
movq %rax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x4028b
testb $0x10, 0x5(%rbx)
jne 0x40296
cmpb $0x0, (%rax)
jne 0x40296
cmpl $0x22, (%r14)
jne 0x402a0
movl $0x4, 0x19214(%rbx)
movl 0x19214(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_inlong
SOAP_FMAC1
long *
SOAP_FMAC2
soap_inlong(struct soap *soap, const char *tag, long *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":int")
   && soap_match_tag(soap, soap->type, ":short")
   && soap_match_tag(soap, soap->type, ":byte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(long), 0, NULL);
  else if (p)
  { if (soap_s2long(soap, soap_value(soap), p))
      return NULL;
  }
  if (soap->body && soap_element_end_in(soap, tag))
    return NULL;
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36f8a
testl %eax, %eax
jne 0x40401
cmpb $0x0, 0x17538(%rbx)
je 0x40360
leaq 0x17538(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x380f0
testl %eax, %eax
je 0x40360
leaq 0xb8ad(%rip), %rdx      # 0x4bbbb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40360
leaq 0xd40f(%rip), %rdx      # 0x4d733
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40360
leaq 0xb878(%rip), %rdx      # 0x4bbb2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x40360
movl $0x4, 0x19214(%rbx)
movq %rbx, %rdi
callq 0x3ed4a
jmp 0x403fe
leaq 0x16d38(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x8
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x3c1b5
movq %rax, %r15
cmpb $0x0, 0x17138(%rbx)
je 0x403df
leaq 0x17138(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x8, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3c06d
movq %rax, %r15
cmpw $0x0, 0x6106(%rbx)
je 0x40401
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3713c
testl %eax, %eax
jne 0x403fe
jmp 0x40401
testq %r15, %r15
je 0x40413
movq %rbx, %rdi
callq 0x4010f
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4023f
testl %eax, %eax
je 0x403c4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x403c4
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outLONG64
SOAP_FMAC2
soap_outLONG64(struct soap *soap, const char *tag, int id, const LONG64 *p, const char *type, int n)
{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
   || soap_string_out(soap, soap_LONG642s(soap, *p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x3b587
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x3b9c9
testl %eax, %eax
jne 0x4048a
movq (%r15), %rsi
movq %r14, %rdi
callq 0x40418
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3e651
testl %eax, %eax
je 0x4049d
movl 0x19214(%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ba46