LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outwstring
SOAP_FMAC2
soap_outwstring(struct soap *soap, const char *tag, int id, wchar_t *const*p, const char *type, int n) 
{ id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
  if (id < 0)
    return soap->error;
  if (!**p && (soap->mode & SOAP_C_NILSTRING))
    return soap_element_null(soap, tag, id, type);
  if (soap_element_begin_out(soap, tag, id, type)
   || soap_wstring_out(soap, *p, 0)
   || soap_element_end_out(soap, tag))
    return soap->error;
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %eax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rcx), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r12
callq 0x3b8f6
addq $0x10, %rsp
testl %eax, %eax
js 0x424ef
movq (%r15), %rcx
cmpl $0x0, (%rcx)
jne 0x424b9
testb $-0x80, 0x6(%rbx)
jne 0x42500
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x3b9c9
testl %eax, %eax
jne 0x424ef
movq (%r15), %rsi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3f9e4
testl %eax, %eax
jne 0x424ef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ba46
testl %eax, %eax
je 0x424f5
movl 0x19214(%rbx), %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3e8c0
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_timegm
SOAP_FMAC2
soap_timegm(struct tm *T)
{
#if defined(HAVE_TIMEGM)
  return timegm(T);
#else
  time_t t, g, z;
  struct tm tm;
  t = mktime(T);
  if (t == (time_t)-1)
    return (time_t)-1;
#ifdef HAVE_GMTIME_R
  gmtime_r(&t, &tm);
#else
  tm = *gmtime(&t);
#endif
  tm.tm_isdst = 0;
  g = mktime(&tm);
  if (g == (time_t)-1)
    return (time_t)-1;
  z = g - t;
  return t - z;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0x32e0
movq %rax, 0x8(%rsp)
pushq $-0x1
popq %rbx
cmpq $-0x1, %rax
je 0x426cd
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x3170
andl $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x32e0
cmpq $-0x1, %rax
je 0x426cd
movq 0x8(%rsp), %rbx
addq %rbx, %rbx
subq %rax, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outdateTime
SOAP_FMAC2
soap_outdateTime(struct soap *soap, const char *tag, int id, const time_t *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_dateTime2s(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 0x42789
movq (%r15), %rsi
movq %r14, %rdi
callq 0x426d8
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3e651
testl %eax, %eax
je 0x4279c
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_indateTime
SOAP_FMAC1
time_t *
SOAP_FMAC2
soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":dateTime"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
  p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(time_t), 0, NULL);
  else if (p)
  { if (soap_s2dateTime(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 0x42ac6
cmpb $0x0, 0x17538(%rbx)
je 0x42a25
leaq 0x17538(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x380f0
testl %eax, %eax
je 0x42a25
leaq 0xae6e(%rip), %rdx      # 0x4d86d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x380f0
testl %eax, %eax
je 0x42a25
movl $0x4, 0x19214(%rbx)
movq %rbx, %rdi
callq 0x3ed4a
jmp 0x42ac3
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 0x42aa4
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 0x42ac6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3713c
testl %eax, %eax
jne 0x42ac3
jmp 0x42ac6
testq %r15, %r15
je 0x42ad8
movq %rbx, %rdi
callq 0x4010f
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x427b2
testl %eax, %eax
je 0x42a89
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 0x42a89
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_outliteral
SOAP_FMAC2
soap_outliteral(struct soap *soap, const char *tag, char *const*p, const char *type)
{ int i;
  const char *t = NULL;
  if (tag && *tag != '-')
  { if (soap->local_namespaces && (t = strchr(tag, ':')))
    { strncpy(soap->tmpbuf, tag, t-tag);
      soap->tmpbuf[t-tag] = '\0';
      for (i = 0; soap->local_namespaces[i].id; i++)
        if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
          break;
      t++;
      if (soap_element(soap, t, 0, type)
       || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
       || soap_element_start_end_out(soap, NULL))
        return soap->error;
    }
    else
    { t = tag;
      if (soap_element_begin_out(soap, t, 0, type))
        return soap->error;
    }
  }
  if (p && *p)
  { if (soap_send(soap, *p))
      return soap->error;
  }
  if (t)
    return soap_element_end_out(soap, t);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x42afb
movq %rsi, %r12
cmpb $0x2d, (%rsi)
jne 0x42b3d
xorl %r12d, %r12d
testq %r14, %r14
je 0x42b1b
movq (%r14), %rsi
testq %rsi, %rsi
je 0x42b1b
movq %rbx, %rdi
callq 0x34a3f
testl %eax, %eax
jne 0x42c1f
testq %r12, %r12
je 0x42c03
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ba46
movq %rcx, %r13
cmpq $0x0, 0x80(%rbx)
je 0x42c07
pushq $0x3a
popq %rsi
movq %r12, %rdi
callq 0x3130
testq %rax, %rax
je 0x42c07
leaq 0x16538(%rbx), %rbp
movq %rax, (%rsp)
movq %rax, %r15
subq %r12, %r15
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3070
movb $0x0, 0x16538(%rbx,%r15)
movq 0x80(%rbx), %r12
xorl %ecx, %ecx
movq %rcx, %r15
movq (%r12,%rcx), %rsi
testq %rsi, %rsi
je 0x42baf
movq %rbp, %rdi
callq 0x3210
leaq 0x20(%r15), %rcx
testl %eax, %eax
jne 0x42b93
movq (%rsp), %rsi
incq %rsi
movq %rbx, %rdi
movq %rsi, %r12
xorl %edx, %edx
movq %r13, %rcx
callq 0x3d76d
testl %eax, %eax
jne 0x42c1f
movq 0x80(%rbx), %rax
movq 0x8(%rax,%r15), %rax
testq %rax, %rax
leaq 0xa581(%rip), %rdx      # 0x4d161
cmovneq %rax, %rdx
leaq 0xa984(%rip), %rsi      # 0x4d56f
movq %rbx, %rdi
callq 0x3ddbf
testl %eax, %eax
jne 0x42c1f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3df2b
jmp 0x42c17
xorl %eax, %eax
jmp 0x42c25
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x3b9c9
testl %eax, %eax
je 0x42afe
movl 0x19214(%rbx), %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_outwliteral
SOAP_FMAC2
soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p, const char *type)
{ int i;
  const char *t = NULL;
  if (tag && *tag != '-')
  { if (soap->local_namespaces && (t = strchr(tag, ':')))
    { strncpy(soap->tmpbuf, tag, t-tag);
      soap->tmpbuf[t-tag] = '\0';
      for (i = 0; soap->local_namespaces[i].id; i++)
        if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
          break;
      t++;
      if (soap_element(soap, t, 0, type)
       || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
       || soap_element_start_end_out(soap, NULL))
        return soap->error;
    }
    else
    { t = tag;
      if (soap_element_begin_out(soap, t, 0, type))
        return soap->error;
    }
    if (soap_send(soap, soap->tmpbuf))
      return soap->error;
  }
  if (p)
  { wchar_t c;
    const wchar_t *s = *p;
    while ((c = *s++))
    { if (soap_pututf8(soap, (unsigned long)c))
        return soap->error;
    }
  }
  if (t)
    return soap_element_end_out(soap, t);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x42d49
movq %rsi, %r15
cmpb $0x2d, (%rsi)
jne 0x42d93
xorl %r15d, %r15d
testq %r14, %r14
je 0x42d71
movq (%r14), %r14
movslq (%r14), %rsi
testq %rsi, %rsi
je 0x42d71
addq $0x4, %r14
movq %rbx, %rdi
callq 0x35941
testl %eax, %eax
je 0x42d54
jmp 0x42e87
testq %r15, %r15
je 0x42e8f
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ba46
movq %rcx, %r13
cmpq $0x0, 0x80(%rbx)
je 0x42e5c
pushq $0x3a
popq %rsi
movq %r15, %rdi
callq 0x3130
testq %rax, %rax
je 0x42e5c
leaq 0x16538(%rbx), %rbp
movq %rax, (%rsp)
movq %rax, %r12
subq %r15, %r12
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3070
movb $0x0, 0x16538(%rbx,%r12)
movq 0x80(%rbx), %r12
xorl %ecx, %ecx
movq %rcx, %r15
movq (%r12,%rcx), %rsi
testq %rsi, %rsi
je 0x42e05
movq %rbp, %rdi
callq 0x3210
leaq 0x20(%r15), %rcx
testl %eax, %eax
jne 0x42de9
movq (%rsp), %r12
incq %r12
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x3d76d
testl %eax, %eax
jne 0x42e87
movq 0x80(%rbx), %rax
movq 0x8(%rax,%r15), %rax
testq %rax, %rax
leaq 0xa32b(%rip), %rdx      # 0x4d161
cmovneq %rax, %rdx
leaq 0xa72e(%rip), %rsi      # 0x4d56f
movq %rbx, %rdi
callq 0x3ddbf
testl %eax, %eax
jne 0x42e87
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3df2b
movq %r12, %r15
jmp 0x42e6c
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x3b9c9
testl %eax, %eax
jne 0x42e87
leaq 0x16538(%rbx), %rsi
movq %rbx, %rdi
callq 0x34a3f
testl %eax, %eax
je 0x42d4c
movl 0x19214(%rbx), %eax
jmp 0x42e91
xorl %eax, %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_getline
SOAP_FMAC2
soap_getline(struct soap *soap, char *s, int len)
{ int i = len;
  soap_wchar c = 0;
  for (;;)
  { while (--i > 0)
    { c = soap_getchar(soap);
      if (c == '\r' || c == '\n')
        break;
      if ((int)c == EOF)
        return soap->error = SOAP_EOF;
      *s++ = (char)c;
    }
    if (c != '\n')
      c = soap_getchar(soap); /* got \r or something else, now get \n */
    if (c == '\n')
    { *s = '\0';
      if (i+1 == len) /* empty line: end of HTTP/MIME header */
        break;
      c = soap_get0(soap);
      if (c != ' ' && c != '\t') /* HTTP line continuation? */
        break;
    }
    else if ((int)c == EOF)
      return soap->error = SOAP_EOF;
    if (i < 0)
      return soap->error = SOAP_HDR;
  }
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %edx, %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
pushq $0x1
popq %r13
cmovlel %ebp, %r13d
cmpl $0x2, %ebp
jl 0x42fe7
movq %rbx, %rdi
callq 0x34fa6
cmpl $-0x1, %eax
je 0x4304c
cmpl $0xa, %eax
je 0x42fe4
cmpl $0xd, %eax
je 0x42fe4
movb %al, (%r14)
incq %r14
decl %ebp
jmp 0x42fbe
movl %ebp, %r13d
cmpl $0xa, %eax
je 0x43000
movq %rbx, %rdi
callq 0x34fa6
cmpl $0xa, %eax
je 0x43000
cmpl $-0x1, %eax
jne 0x4303e
jmp 0x4304c
movb $0x0, (%r14)
cmpl %r12d, %r13d
je 0x43055
movq 0x60f0(%rbx), %rax
cmpq 0x60f8(%rbx), %rax
jb 0x4302c
movq %rbx, %rdi
callq 0x34dd5
testl %eax, %eax
jne 0x43055
movq 0x60f0(%rbx), %rax
movzbl 0x6138(%rbx,%rax), %eax
cmpl $0x20, %eax
je 0x4303e
cmpl $0x9, %eax
jne 0x43055
decl %ebp
testl %r13d, %r13d
jg 0x42fb4
pushq $0x16
popq %rax
movl %eax, 0x19214(%rbx)
movl %eax, %r15d
movl %r15d, %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_dime_option
SOAP_FMAC1
char *
SOAP_FMAC2
soap_dime_option(struct soap *soap, unsigned short optype, const char *option)
{ size_t n;
  char *s = NULL;
  if (option)
  { n = strlen(option);
    s = (char*)soap_malloc(soap, n + 5);
    if (s)
    { s[0] = (char)(optype >> 8);
      s[1] = (char)(optype & 0xFF);
      s[2] = (char)(n >> 8);
      s[3] = (char)(n & 0xFF);
      strcpy(s + 4, option);
    }
  }
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x430bf
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
movq %rdx, %rdi
callq 0x3110
movq %rax, %r12
leaq 0x5(%rax), %rsi
movq %r14, %rdi
callq 0x35f17
testq %rax, %rax
je 0x430bf
movq %rax, %rbp
movl %r15d, %eax
movb %ah, (%rbp)
movb %al, 0x1(%rbp)
movq %r12, %rax
movb %ah, 0x2(%rbp)
movb %al, 0x3(%rbp)
movq %rbp, %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x3090
jmp 0x430c1
xorl %ebp, %ebp
movq %rbp, %rax
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_putdimehdr
SOAP_FMAC2
soap_putdimehdr(struct soap *soap)
{ unsigned char tmp[12];
  size_t optlen = 0, idlen = 0, typelen = 0;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id?soap->dime.id:SOAP_STR_EOS));
  if (soap->dime.options)
    optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4;
  if (soap->dime.id)
  { idlen = strlen(soap->dime.id);
    if (idlen > 0x0000FFFF)
      idlen = 0x0000FFFF;
  }
  if (soap->dime.type)
  { typelen = strlen(soap->dime.type);
    if (typelen > 0x0000FFFF)
      typelen = 0x0000FFFF;
  }
  tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7);
  tmp[1] = soap->dime.flags & 0xF0;
  tmp[2] = (char)(optlen >> 8);
  tmp[3] = (char)(optlen & 0xFF);
  tmp[4] = (char)(idlen >> 8);
  tmp[5] = (char)(idlen & 0xFF);
  tmp[6] = (char)(typelen >> 8);
  tmp[7] = (char)(typelen & 0xFF);
  tmp[8] = (char)(soap->dime.size >> 24);
  tmp[9] = (char)((soap->dime.size >> 16) & 0xFF);
  tmp[10] = (char)((soap->dime.size >> 8) & 0xFF);
  tmp[11] = (char)(soap->dime.size & 0xFF);
  if (soap_send_raw(soap, (char*)tmp, 12)
   || soap_putdimefield(soap, soap->dime.options, optlen)
   || soap_putdimefield(soap, soap->dime.id, idlen)
   || soap_putdimefield(soap, soap->dime.type, typelen))
    return soap->error;
  return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x19268(%rdi), %rax
testq %rax, %rax
je 0x430f8
movzwl 0x2(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %ebx
addq $0x4, %rbx
jmp 0x430fa
xorl %ebx, %ebx
movq 0x19258(%r14), %rdi
testq %rdi, %rdi
je 0x4311a
callq 0x3110
movl $0xffff, %r15d          # imm = 0xFFFF
cmpq %r15, %rax
cmovbq %rax, %r15
jmp 0x4311d
xorl %r15d, %r15d
movq 0x19260(%r14), %rdi
testq %rdi, %rdi
je 0x4313c
callq 0x3110
movl $0xffff, %edx           # imm = 0xFFFF
cmpq %rdx, %rax
cmovbq %rax, %rdx
jmp 0x4313e
xorl %edx, %edx
movb 0x19248(%r14), %al
movl %eax, %ecx
andb $0x7, %cl
orb $0x8, %cl
leaq 0xc(%rsp), %rsi
movb %cl, (%rsi)
andb $-0x10, %al
movb %al, 0x1(%rsi)
movb %bh, 0xe(%rsp)
movb %bl, 0x3(%rsi)
movq %r15, %rax
movb %ah, 0x10(%rsp)
movb %al, 0x5(%rsi)
movb %dh, 0x12(%rsp)
movq %rdx, %r12
movb %dl, 0x7(%rsi)
movl 0x19230(%r14), %eax
bswapl %eax
movl %eax, 0x8(%rsi)
pushq $0xc
popq %rdx
movq %r14, %rdi
callq 0x347c4
testl %eax, %eax
jne 0x431d1
movq 0x19268(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x431e8
testl %eax, %eax
jne 0x431d1
movq 0x19258(%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x431e8
testl %eax, %eax
jne 0x431d1
movq 0x19260(%r14), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x431e8
testl %eax, %eax
je 0x431e4
movl 0x19214(%r14), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x431d8
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_getdimefield
static char *
soap_getdimefield(struct soap *soap, size_t n)
{ register soap_wchar c;
  register size_t i;
  register char *s;
  register char *p = NULL;
  if (n)
  { p = (char*)soap_malloc(soap, n + 1);
    if (p)
    { s = p;
      for (i = n; i > 0; i--)
      { if ((int)(c = soap_get1(soap)) == EOF)
        { soap->error = SOAP_EOF;
          return NULL;
        }
        *s++ = (char)c;
      }
      *s = '\0';
      if ((soap->error = soap_move(soap, -(long)n&3)))
        return NULL;
    }
    else
      soap->error = SOAP_EOM;
  }
  return p;
}

// Assembly:
testq %rsi, %rsi
je 0x43438
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
incq %rsi
callq 0x35f17
testq %rax, %rax
je 0x43464
movq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x4343b
movq 0x60f0(%rbx), %rax
cmpq 0x60f8(%rbx), %rax
jb 0x4341d
movq %rbx, %rdi
callq 0x34dd5
testl %eax, %eax
jne 0x43470
movq 0x60f0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60f0(%rbx)
movb 0x6138(%rbx,%rax), %al
movb %al, (%r15,%r12)
incq %r12
jmp 0x433f5
xorl %eax, %eax
retq
movb $0x0, (%r15,%r12)
negl %r14d
andl $0x3, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x358ee
movl %eax, %ecx
movl %eax, 0x19214(%rbx)
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %r15, %rax
jmp 0x43479
movl $0x14, 0x19214(%rbx)
jmp 0x43477
orl $-0x1, 0x19214(%rbx)
xorl %eax, %eax
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_set_mime_attachment
SOAP_FMAC2
soap_set_mime_attachment(struct soap *soap, char *ptr, size_t size, enum soap_mime_encoding encoding, const char *type, const char *id, const char *location, const char *description)
{ struct soap_multipart *content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, ptr, size);
  if (!content)
    return SOAP_EOM;
  content->id = soap_strdup(soap, id);
  content->type = soap_strdup(soap, type);
  content->encoding = encoding;
  content->location = soap_strdup(soap, location);
  content->description = soap_strdup(soap, description);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x192a0(%rdi), %rsi
leaq 0x192a8(%rdi), %rdx
callq 0x3bb26
testq %rax, %rax
je 0x43754
movq %rax, %r14
movq 0x40(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x37284
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37284
movq %rax, 0x20(%r14)
movl %ebp, 0x30(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x37284
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq 0x48(%rsp), %rsi
callq 0x37284
movq %rax, 0x40(%r14)
xorl %eax, %eax
jmp 0x43757
pushq $0x14
popq %rax
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_get_header_attribute
SOAP_FMAC1
const char*
SOAP_FMAC2
soap_get_header_attribute(struct soap *soap, const char *line, const char *key)
{ register const char *s = line;
  if (s)
  { while (*s)
    { register short flag;
      s = soap_decode_key(soap->tmpbuf, sizeof(soap->tmpbuf), s);
      flag = soap_tag_cmp(soap->tmpbuf, key);
      s = soap_decode_val(soap->tmpbuf, sizeof(soap->tmpbuf), s);
      if (!flag)
        return soap->tmpbuf;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x437be
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
addq $0x16538, %rbx          # imm = 0x16538
cmpb $0x0, (%rax)
je 0x437be
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %rax, %rdx
callq 0x443c5
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3507f
movl %eax, %ebp
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r15, %rdx
callq 0x443d1
testw %bp, %bp
jne 0x43782
jmp 0x437c0
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_match_cid
SOAP_FMAC2
soap_match_cid(struct soap *soap, const char *s, const char *t)
{ register size_t n;
  if (!s)
    return 1;
  if (!strcmp(s, t))
    return 0;
  if (!strncmp(s, "cid:", 4))
    s += 4;
  n = strlen(t);
  if (*t == '<')
  { t++;
    n -= 2;
  }
  if (!strncmp(s, t, n) && !s[n])
    return 0;
  soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS);
  if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n])
    return 0;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
testq %rsi, %rsi
je 0x43c43
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3210
xorl %ebx, %ebx
testl %eax, %eax
je 0x43c43
leaq 0x995c(%rip), %rsi      # 0x4d518
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x3080
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leaq (%r12,%rcx,4), %r13
movq %r15, %rdi
callq 0x3110
leaq -0x2(%rax), %r12
xorl %ebp, %ebp
cmpb $0x3c, (%r15)
sete %bpl
cmovneq %rax, %r12
addq %r15, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3080
testl %eax, %eax
jne 0x43c09
cmpb $0x0, (%r13,%r12)
je 0x43c43
addq $0x16538, %r14          # imm = 0x16538
leaq 0x954a(%rip), %rcx      # 0x4d161
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r13, %rdx
callq 0x43c54
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3080
testl %eax, %eax
jne 0x43c40
cmpb $0x0, (%r14,%r12)
je 0x43c43
pushq $0x1
popq %rbx
movl %ebx, %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_decode
static const char*
soap_decode(char *buf, size_t len, const char *val, const char *sep)
{ const char *s;
  char *t = buf;
  for (s = val; *s; s++)
    if (*s != ' ' && *s != '\t' && !strchr(sep, *s))
      break;
  if (*s == '"')
  { s++;
    while (*s && *s != '"' && --len)
      *t++ = *s++;
  }
  else
  { while (*s && !soap_blank(*s) && !strchr(sep, *s) && --len)
    { if (*s == '%')
      { *t++ = ((s[1] >= 'A' ? (s[1] & 0x7) + 9 : s[1] - '0') << 4)
              + (s[2] >= 'A' ? (s[2] & 0x7) + 9 : s[2] - '0');
        s += 3;
      }
      else
        *t++ = *s++;
    }
  }
  *t = '\0';
  while (*s && !strchr(sep, *s))
    s++;
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movzbl (%rbx), %ebp
cmpl $0x9, %ebp
je 0x43c8a
cmpl $0x20, %ebp
je 0x43c8a
testl %ebp, %ebp
je 0x43cbc
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
je 0x43c8f
incq %rbx
jmp 0x43c68
cmpb $0x22, %bpl
jne 0x43cbc
incq %rbx
decq %r12
movzbl (%rbx), %eax
testl %eax, %eax
je 0x43d2a
cmpl $0x22, %eax
je 0x43d2a
subq $0x1, %r12
jb 0x43d2a
movb %al, (%r15)
incq %r15
incq %rbx
jmp 0x43c9b
decq %r12
cmpb $0x21, %bpl
jb 0x43d2a
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
jne 0x43d2a
subq $0x1, %r12
jb 0x43d2a
cmpb $0x25, %bpl
jne 0x43d1c
movzbl 0x1(%rbx), %eax
movl %eax, %ecx
andb $0x7, %cl
addb $0x9, %cl
cmpb $0x41, %al
movzbl %cl, %ecx
cmovll %eax, %ecx
shlb $0x4, %cl
movb 0x2(%rbx), %al
movl %eax, %edx
andb $0x7, %dl
addb $0x9, %dl
leal -0x30(%rax), %esi
cmpb $0x41, %al
movzbl %sil, %eax
movzbl %dl, %ebp
cmovll %eax, %ebp
addb %cl, %bpl
addq $0x3, %rbx
jmp 0x43d1f
incq %rbx
movb %bpl, (%r15)
incq %r15
movb (%rbx), %bpl
jmp 0x43cbf
movb $0x0, (%r15)
movsbl (%rbx), %esi
testl %esi, %esi
je 0x43d47
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
jne 0x43d47
incq %rbx
jmp 0x43d2e
movq %rbx, %rax
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_putmimehdr
SOAP_FMAC2
soap_putmimehdr(struct soap *soap, struct soap_multipart *content)
{ const char *s;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type=%s\n", content->type?content->type:SOAP_STR_EOS));
  if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n"))
    return soap->error;
  if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n"))
    return soap->error;
  s = soap_code_str(mime_codes, content->encoding);
  if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n"))
    return soap->error;
  if (content->id && soap_send3(soap, "Content-ID: ", content->id, "\r\n"))
    return soap->error;
  if (content->location && soap_send3(soap, "Content-Location: ", content->location, "\r\n"))
    return soap->error;
  if (content->description && soap_send3(soap, "Content-Description: ", content->description, "\r\n"))
    return soap->error;
  return soap_send_raw(soap, "\r\n", 2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x19288(%rdi), %rdx
leaq 0x9b77(%rip), %rsi      # 0x4d8e2
leaq 0x97b0(%rip), %rcx      # 0x4d522
callq 0x34aa2
testl %eax, %eax
je 0x43d89
movl 0x19214(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x43dac
leaq 0x9b4e(%rip), %rsi      # 0x4d8e7
leaq 0x9782(%rip), %rcx      # 0x4d522
movq %rbx, %rdi
callq 0x34aa2
testl %eax, %eax
jne 0x43d7b
movl 0x30(%r14), %esi
leaq 0x2b6d9(%rip), %rdi     # 0x6f490
callq 0x35176
testq %rax, %rax
je 0x43dde
leaq 0x9b2e(%rip), %rsi      # 0x4d8f6
leaq 0x9753(%rip), %rcx      # 0x4d522
movq %rbx, %rdi
movq %rax, %rdx
callq 0x34aa2
testl %eax, %eax
jne 0x43d7b
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x43e05
leaq 0x9b24(%rip), %rsi      # 0x4d912
leaq 0x972d(%rip), %rcx      # 0x4d522
movq %rbx, %rdi
callq 0x34aa2
testl %eax, %eax
jne 0x43d7b
movq 0x38(%r14), %rdx
testq %rdx, %rdx
je 0x43e2c
leaq 0x9b0a(%rip), %rsi      # 0x4d91f
leaq 0x9706(%rip), %rcx      # 0x4d522
movq %rbx, %rdi
callq 0x34aa2
testl %eax, %eax
jne 0x43d7b
movq 0x40(%r14), %rdx
testq %rdx, %rdx
je 0x43e53
leaq 0x9af6(%rip), %rsi      # 0x4d932
leaq 0x96df(%rip), %rcx      # 0x4d522
movq %rbx, %rdi
callq 0x34aa2
testl %eax, %eax
jne 0x43d7b
leaq 0x96c8(%rip), %rsi      # 0x4d522
pushq $0x2
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x347c4
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_mime
SOAP_FMAC2
soap_set_mime(struct soap *soap, const char *boundary, const char *start)
{ soap->omode |= SOAP_ENC_MIME;
  soap->mime.first = NULL;
  soap->mime.last = NULL;
  soap->mime.boundary = soap_strdup(soap, boundary);
  soap->mime.start = soap_strdup(soap, start);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $0x1, 0xd(%rdi)
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x192a0(%rdi)
callq 0x37284
movq %rax, 0x19288(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37284
movq %rax, 0x19290(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_dime_attachment
SOAP_FMAC2
soap_set_dime_attachment(struct soap *soap, char *ptr, size_t size, const char *type, const char *id, unsigned short optype, const char *option)
{ struct soap_multipart *content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, ptr, size);
  if (!content)
    return SOAP_EOM;
  content->id = soap_strdup(soap, id);
  content->type = soap_strdup(soap, type);
  content->options = soap_dime_option(soap, optype, option);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x19278(%rdi), %rsi
leaq 0x19280(%rdi), %rdx
callq 0x3bb26
testq %rax, %rax
je 0x43f3c
movq %rax, %r12
movq 0x40(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x37284
movq %rax, 0x18(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x37284
movq %rax, 0x20(%r12)
movzwl %bx, %esi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x43067
movq %rax, 0x28(%r12)
xorl %eax, %eax
jmp 0x43f3f
pushq $0x14
popq %rax
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_envelope_begin_out
SOAP_FMAC2
soap_envelope_begin_out(struct soap *soap)
{
#ifndef WITH_LEANER
  size_t n = 0;
  if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start && strlen(soap->mime.boundary) + strlen(soap->mime.start) < sizeof(soap->tmpbuf) - 80 )
  { const char *s;
    if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
      s = "application/dime";
    else if (soap->version == 2)
    { if (soap->mode & SOAP_ENC_MTOM)
        s = "application/xop+xml; charset=utf-8; type=\"application/soap+xml\"";
      else
        s = "application/soap+xml; charset=utf-8";
    }
    else if (soap->mode & SOAP_ENC_MTOM)
      s = "application/xop+xml; charset=utf-8; type=\"text/xml\"";
    else
      s = "text/xml; charset=utf-8";
    sprintf(soap->tmpbuf, "--%s\r\nContent-Type: %s\r\nContent-Transfer-Encoding: binary\r\nContent-ID: %s\r\n\r\n", soap->mime.boundary, s, soap->mime.start);
    n = strlen(soap->tmpbuf);
    if (soap_send_raw(soap, soap->tmpbuf, n))
      return soap->error;
  }
  if (soap->mode & SOAP_IO_LENGTH)
    soap->dime.size = soap->count;	/* DIME in MIME correction */
  if (!(soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME))
  { if (soap_putdimehdr(soap))
      return soap->error;
  }
#endif
  soap->part = SOAP_IN_ENVELOPE;
  return soap_element_begin_out(soap, "SOAP-ENV:Envelope", 0, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
btl $0x8, %ebp
jae 0x444c9
movq 0x19288(%rbx), %r14
testq %r14, %r14
je 0x444c9
movq 0x19290(%rbx), %r15
testq %r15, %r15
je 0x444c9
movq %r14, %rdi
callq 0x3110
movq %rax, %r12
movq %r15, %rdi
callq 0x3110
addq %r12, %rax
cmpq $0x3af, %rax            # imm = 0x3AF
ja 0x444c9
movl %ebp, %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x80, %eax
jne 0x4445d
leaq 0x94ed(%rip), %rcx      # 0x4d948
jmp 0x4448e
cmpw $0x2, 0x2(%rbx)
jne 0x44478
btl $0x9, %ebp
leaq 0x952e(%rip), %rax      # 0x4d99d
leaq 0x94e7(%rip), %rcx      # 0x4d95d
jmp 0x4448a
btl $0x9, %ebp
leaq 0x9572(%rip), %rax      # 0x4d9f5
leaq 0x9537(%rip), %rcx      # 0x4d9c1
cmovaeq %rax, %rcx
leaq 0x16538(%rbx), %r12
leaq 0x9571(%rip), %rsi      # 0x4da0d
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x3370
movq %r12, %rdi
callq 0x3110
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x347c4
testl %eax, %eax
jne 0x444f7
movl 0x4(%rbx), %ebp
testb $0x8, %bpl
je 0x444dd
movq 0x6110(%rbx), %rax
movq %rax, 0x19230(%rbx)
andl $0x88, %ebp
cmpl $0x80, %ebp
jne 0x44506
movq %rbx, %rdi
callq 0x430cd
testl %eax, %eax
je 0x44506
movl 0x19214(%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movw $0x2, 0x18590(%rbx)
leaq 0x9545(%rip), %rsi      # 0x4da5b
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3b9c9
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_envelope_end_out
SOAP_FMAC2
soap_envelope_end_out(struct soap *soap)
{ if (soap_element_end_out(soap, "SOAP-ENV:Envelope") || ((soap->mode & SOAP_XML_INDENT) && soap_send_raw(soap, "\r\n", 2)))
    return soap->error;
#ifndef WITH_LEANER
  if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
  { soap->dime.size = soap->count - soap->dime.size;	/* DIME in MIME correction */
    sprintf(soap->id, soap->dime_id_format, 0);
    soap->dime.id = soap->id;
    if (soap->local_namespaces)
    { if (soap->local_namespaces[0].out)
        soap->dime.type = (char*)soap->local_namespaces[0].out;
      else
        soap->dime.type = (char*)soap->local_namespaces[0].ns;
    }
    soap->dime.options = NULL;
    soap->dime.flags = SOAP_DIME_MB | SOAP_DIME_ABSURI;
    if (!soap->dime.first)
      soap->dime.flags |= SOAP_DIME_ME;
    soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + (soap->dime.type ? ((strlen(soap->dime.type)+3)&(~3)) : 0);
  }
  if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
    return soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
#endif
  soap->part = SOAP_END_ENVELOPE;
  return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9522(%rip), %rsi      # 0x4da5b
callq 0x3ba46
testl %eax, %eax
je 0x4454e
movl 0x19214(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x4(%rbx), %eax
btl $0xd, %eax
jae 0x44570
leaq 0x8fc4(%rip), %rsi      # 0x4d522
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x347c4
testl %eax, %eax
jne 0x44542
movl 0x4(%rbx), %eax
movl %eax, %ecx
andl $0x288, %ecx            # imm = 0x288
cmpl $0x88, %ecx
jne 0x4463a
movq 0x6110(%rbx), %rax
subq 0x19230(%rbx), %rax
movq %rax, 0x19230(%rbx)
leaq 0x16d38(%rbx), %r14
movq 0x20(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3370
movq %r14, 0x19258(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x445d9
movq 0x18(%rax), %r15
testq %r15, %r15
jne 0x445d0
movq 0x8(%rax), %r15
movq %r15, 0x19260(%rbx)
jmp 0x445e0
movq 0x19260(%rbx), %r15
andq $0x0, 0x19268(%rbx)
cmpq $0x0, 0x19278(%rbx)
sete %al
addb %al, %al
orb $0x24, %al
movb %al, 0x19248(%rbx)
movq %r14, %rdi
callq 0x3110
movq %rax, %r14
addq $0x3, %r14
andq $-0x4, %r14
addq $0xc, %r14
testq %r15, %r15
je 0x4462b
movq %r15, %rdi
callq 0x3110
addq $0x3, %rax
andq $-0x4, %rax
jmp 0x4462d
xorl %eax, %eax
addq %rax, %r14
addq %r14, 0x6110(%rbx)
movl 0x4(%rbx), %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x80, %eax
jne 0x44665
xorl %edx, %edx
subl 0x19230(%rbx), %edx
andl $0x3, %edx
leaq 0x8b09(%rip), %rsi      # 0x4d161
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x347c4
movw $0x8, 0x18590(%rbx)
xorl %eax, %eax
jmp 0x44548
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_envelope_begin_in
SOAP_FMAC2
soap_envelope_begin_in(struct soap *soap)
{ register struct Namespace *p;
  soap->part = SOAP_IN_ENVELOPE;
  if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL))
  { if (soap->error == SOAP_TAG_MISMATCH
     && !soap_element_begin_in(soap, "Envelope", 0, NULL))
      soap->error = SOAP_VERSIONMISMATCH;
    else if (soap->status)
      soap->error = soap->status;
    return soap->error;
  }
  p = soap->local_namespaces;
  if (p)
  { const char *ns = p[0].out;
    if (!ns)
      ns = p[0].ns;
    if (!strcmp(ns, soap_env1))
    { soap->version = 1; /* make sure we use SOAP 1.1 */
      if (p[1].out)
        SOAP_FREE(soap, p[1].out);
      if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc1))))
        strcpy(p[1].out, soap_enc1);
    }
    else if (!strcmp(ns, soap_env2))
    { soap->version = 2; /* make sure we use SOAP 1.2 */
      if (p[1].out)
        SOAP_FREE(soap, p[1].out);
      if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc2))))
        strcpy(p[1].out, soap_enc2);
    }
  }
  return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movw $0x2, 0x18590(%rdi)
leaq 0x93cb(%rip), %rsi      # 0x4da5b
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36f8a
testl %eax, %eax
je 0x446df
cmpl $0x3, 0x19214(%r14)
jne 0x446c4
leaq 0x93b4(%rip), %rsi      # 0x4da64
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36f8a
testl %eax, %eax
je 0x4477d
movl 0x19210(%r14), %ebx
testl %ebx, %ebx
je 0x44774
movl %ebx, 0x19214(%r14)
jmp 0x447d0
movq 0x80(%r14), %r12
testq %r12, %r12
je 0x447d0
movq 0x18(%r12), %r15
testq %r15, %r15
jne 0x446fe
movq 0x8(%r12), %r15
leaq 0x8a6b(%rip), %rsi      # 0x4d170
movq %r15, %rdi
callq 0x3210
testl %eax, %eax
je 0x4478d
leaq 0x8ac8(%rip), %rsi      # 0x4d1e0
movq %r15, %rdi
callq 0x3210
testl %eax, %eax
jne 0x447d0
movw $0x2, 0x2(%r14)
movq 0x38(%r12), %rdi
callq 0x3030
pushq $0x28
popq %rdi
callq 0x3290
movq %rax, 0x38(%r12)
testq %rax, %rax
je 0x447d0
movaps 0xa62a(%rip), %xmm0     # 0x4ed80
movups %xmm0, 0x10(%rax)
movaps 0xa60f(%rip), %xmm0     # 0x4ed70
movups %xmm0, (%rax)
movabsq $0x676e69646f636e, %rcx # imm = 0x676E69646F636E
movq %rcx, 0x20(%rax)
jmp 0x447d0
movl 0x19214(%r14), %ebx
jmp 0x447d0
movl $0x27, 0x19214(%r14)
pushq $0x27
popq %rbx
jmp 0x447d0
movw $0x1, 0x2(%r14)
movq 0x38(%r12), %rdi
callq 0x3030
pushq $0x2a
popq %rdi
callq 0x3290
movq %rax, 0x38(%r12)
testq %rax, %rax
je 0x447d0
movups 0xa5a3(%rip), %xmm0     # 0x4ed5a
movups %xmm0, 0x1a(%rax)
movaps 0xa58e(%rip), %xmm0     # 0x4ed50
movups %xmm0, 0x10(%rax)
movaps 0xa573(%rip), %xmm0     # 0x4ed40
movups %xmm0, (%rax)
movl %ebx, %eax
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_body_begin_out
SOAP_FMAC2
soap_body_begin_out(struct soap *soap)
{ soap->part = SOAP_IN_BODY;
  if (soap->version == 1)
    soap->encoding = 1;
#ifndef WITH_LEAN
  if ((soap->mode & SOAP_XML_SEC) && soap_set_attr(soap, "wsu:Id", "Body"))
    return soap->error;
#endif
  if (soap_element(soap, "SOAP-ENV:Body", 0, NULL))
    return soap->error;
  return soap_element_start_end_out(soap, NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movw $0x6, 0x18590(%rdi)
cmpw $0x1, 0x2(%rdi)
jne 0x44810
movw $0x1, 0x18588(%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x44838
leaq 0x9250(%rip), %rsi      # 0x4da6d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3d76d
testl %eax, %eax
jne 0x44852
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x3df2b
leaq 0x8e34(%rip), %rsi      # 0x4d673
leaq 0x9230(%rip), %rdx      # 0x4da76
movq %rbx, %rdi
callq 0x3e2d0
testl %eax, %eax
je 0x44816
movl 0x19214(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_body_begin_in
SOAP_FMAC2
soap_body_begin_in(struct soap *soap)
{ soap->part = SOAP_IN_BODY;
  if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL))
    return soap->error;
  if (!soap->body)
    soap->part = SOAP_NO_BODY;
  return SOAP_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movw $0x6, 0x18590(%rdi)
leaq 0x91d3(%rip), %rsi      # 0x4da6d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36f8a
testl %eax, %eax
je 0x448b2
movl 0x19214(%r14), %ebx
jmp 0x448c7
cmpw $0x0, 0x6106(%r14)
jne 0x448c7
movw $0x5, 0x18590(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_body_end_in
SOAP_FMAC2
soap_body_end_in(struct soap *soap)
{ if (soap->part == SOAP_NO_BODY)
    return soap->error = SOAP_OK;
  soap->part = SOAP_END_BODY;
  return soap_element_end_in(soap, "SOAP-ENV:Body");
}

// Assembly:
cmpw $0x5, 0x18590(%rdi)
jne 0x448e5
andl $0x0, 0x19214(%rdi)
xorl %eax, %eax
retq
movw $0x7, 0x18590(%rdi)
leaq 0x9178(%rip), %rsi      # 0x4da6d
jmp 0x3713c
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_recv_header
SOAP_FMAC2
soap_recv_header(struct soap *soap)
{ if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH)
    soap->error = SOAP_OK;
  if (soap->error == SOAP_OK && soap->fheader)
    soap->error = soap->fheader(soap);
  return soap->error;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x35d0
testl %eax, %eax
setne %cl
movl 0x19214(%rbx), %eax
cmpl $0x3, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x44924
andl $0x0, 0x19214(%rbx)
jmp 0x44928
testl %eax, %eax
jne 0x44943
movq 0x5fb8(%rbx), %rax
testq %rax, %rax
je 0x44941
movq %rbx, %rdi
callq *%rax
movl %eax, 0x19214(%rbx)
jmp 0x44943
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_endpoint
SOAP_FMAC2
soap_set_endpoint(struct soap *soap, const char *endpoint)
{ register const char *s;
  register size_t i, n;
  soap->endpoint[0] = '\0';
  soap->host[0] = '\0';
  soap->path[0] = '/';
  soap->path[1] = '\0';
  soap->port = 80;
  if (!endpoint || !*endpoint)
    return;
#ifdef WITH_OPENSSL
  if (!soap_tag_cmp(endpoint, "https:*"))
    soap->port = 443;
#endif
  strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint) - 1);
  soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
  s = strchr(endpoint, ':');
  if (s && s[1] == '/' && s[2] == '/')
    s += 3;
  else
    s = endpoint;
  n = strlen(s);
  if (n >= sizeof(soap->host))
    n = sizeof(soap->host) - 1;
#ifdef WITH_IPV6
  if (s[0] == '[')
  { s++;
    for (i = 0; i < n; i++)
    { if (s[i] == ']')
      { s++;
        --n;
        break; 
      }
      soap->host[i] = s[i];
    }
  }
  else
  { for (i = 0; i < n; i++)
    { soap->host[i] = s[i];
      if (s[i] == '/' || s[i] == ':')
        break; 
    }
  }
#else
  for (i = 0; i < n; i++)
  { soap->host[i] = s[i];
    if (s[i] == '/' || s[i] == ':')
      break; 
  }
#endif
  soap->host[i] = '\0';
  if (s[i] == ':')
  { soap->port = (int)soap_strtol(s + i + 1, NULL, 10);
    for (i++; i < n; i++)
      if (s[i] == '/')
        break;
  }
  if (i < n && s[i])
  { strncpy(soap->path, s + i, sizeof(soap->path));
    soap->path[sizeof(soap->path) - 1] = '\0';
  }
}

// Assembly:
xorl %eax, %eax
movb %al, 0x185a8(%rdi)
movb %al, 0x18da8(%rdi)
movw $0x2f, 0x189a8(%rdi)
movl $0x50, 0x191c8(%rdi)
testq %rsi, %rsi
je 0x44a79
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x44a70
movq %rdi, %rbx
addq $0x185a8, %rdi          # imm = 0x185A8
movl $0x3ff, %r12d           # imm = 0x3FF
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rsi
callq 0x3070
movb $0x0, 0x189a7(%rbx)
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
je 0x449cd
cmpb $0x2f, 0x1(%rax)
jne 0x449cd
movq %rax, %rcx
addq $0x3, %rcx
cmpb $0x2f, 0x2(%rax)
cmoveq %rcx, %r14
leaq 0x189a8(%rbx), %r15
movq %r14, %rdi
callq 0x3110
cmpq %r12, %rax
cmovbq %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x44a07
movzbl (%r14,%r13), %eax
movb %al, 0x18da8(%rbx,%r13)
cmpl $0x2f, %eax
je 0x44a0a
cmpl $0x3a, %eax
je 0x44a0a
incq %r13
jmp 0x449e6
movq %r12, %r13
movb $0x0, 0x18da8(%rbx,%r13)
cmpb $0x3a, (%r14,%r13)
jne 0x44a47
leaq (%r14,%r13), %rdi
incq %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3230
movl %eax, 0x191c8(%rbx)
leaq 0x1(%r13), %rax
cmpq %r12, %rax
jae 0x44a70
cmpb $0x2f, 0x1(%r14,%r13)
movq %rax, %r13
jne 0x44a31
jmp 0x44a4a
movq %r13, %rax
cmpq %r12, %rax
jae 0x44a70
cmpb $0x0, (%r14,%rax)
je 0x44a70
addq %rax, %r14
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r14, %rsi
callq 0x3070
movb $0x0, 0x18da7(%rbx)
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_connect_command
SOAP_FMAC2
soap_connect_command(struct soap *soap, int http_command, const char *endpoints, const char *action)
{ char *endpoint;
  const char *s;
  if (endpoints && (s = strchr(endpoints, ' ')))
  { endpoint = (char*)SOAP_MALLOC(soap, strlen(endpoints) + 1);
    for (;;)
    { strncpy(endpoint, endpoints, s - endpoints);
      endpoint[s - endpoints] = '\0';
      if (soap_try_connect_command(soap, http_command, endpoint, action) != SOAP_TCP_ERROR)
        break;
      if (!*s)
        break;
      soap->error = SOAP_OK;
      while (*s == ' ')
        s++;
      endpoints = s;
      s = strchr(endpoints, ' ');
      if (!s)
        s = endpoints + strlen(endpoints);
    }
    SOAP_FREE(soap, endpoint);
  }
  else
    soap_try_connect_command(soap, http_command, endpoints, action);
  return soap->error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x44b45
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x3130
testq %rax, %rax
je 0x44b45
movq %rax, %r14
movq %r15, %rdi
callq 0x3110
leaq 0x1(%rax), %rdi
callq 0x3290
movq %rax, %r12
movq %r14, %r13
subq %r15, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3070
movb $0x0, (%r12,%r13)
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x44b75
cmpl $0x1c, %eax
jne 0x44b58
cmpb $0x0, (%r14)
je 0x44b58
andl $0x0, 0x19214(%rbx)
decq %r14
movq %r14, %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x44b17
movq %r15, %rdi
pushq $0x20
popq %rsi
callq 0x3130
movq %rax, %r14
testq %rax, %rax
jne 0x44ad5
movq %r15, %rdi
callq 0x3110
movq %rax, %r14
addq %r15, %r14
jmp 0x44ad5
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x44b75
jmp 0x44b60
movq %r12, %rdi
callq 0x3030
movl 0x19214(%rbx), %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_s2base64
SOAP_FMAC1
char*
SOAP_FMAC2
soap_s2base64(struct soap *soap, const unsigned char *s, char *t, int n)
{ register int i;
  register unsigned long m;
  register char *p;
  if (!t)
    t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1);
  if (!t)
    return NULL;
  p = t;
  t[0] = '\0';
  if (!s)
    return p;
  for (; n > 2; n -= 3, s += 3)
  { m = s[0];
    m = (m << 8) | s[1];
    m = (m << 8) | s[2];
    for (i = 4; i > 0; m >>= 6)
      t[--i] = soap_base64o[m & 0x3F];
    t += 4;
  }
  t[0] = '\0';
  if (n > 0)
  { m = 0;
    for (i = 0; i < n; i++)
      m = (m << 8) | *s++;
    for (; i < 3; i++)
      m <<= 8;
    for (i++; i > 0; m >>= 6)
      t[--i] = soap_base64o[m & 0x3F];
    for (i = 3; i > n; i--)
      t[i] = '=';
    t[4] = '\0';
  }
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %rax
movq %rsi, %r14
testq %rdx, %rdx
jne 0x44de3
leal 0x2(%rbx), %eax
pushq $0x3
popq %rcx
cltd
idivl %ecx
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
callq 0x35f17
testq %rax, %rax
je 0x44eb9
movb $0x0, (%rax)
testq %r14, %r14
je 0x44ebb
pushq $0x3
popq %rcx
pushq $0x4
popq %rdi
leaq 0x9ef4(%rip), %rsi      # 0x4ecf0
movq %rax, %rdx
cmpl $0x3, %ebx
jl 0x44e52
movzbl (%r14), %r8d
movzbl 0x1(%r14), %r9d
shll $0x10, %r8d
shll $0x8, %r9d
orl %r8d, %r9d
movzbl 0x2(%r14), %r8d
orq %r9, %r8
movq %rdi, %r10
movq %rdi, %r9
subq $0x1, %r9
jb 0x44e45
movl %r8d, %r11d
andl $0x3f, %r11d
movb (%r11,%rsi), %r11b
movb %r11b, -0x1(%rdx,%r10)
shrq $0x6, %r8
movq %r9, %r10
jmp 0x44e26
addq $0x4, %rdx
addl $-0x3, %ebx
addq $0x3, %r14
jmp 0x44dff
movb $0x0, (%rdx)
testl %ebx, %ebx
jle 0x44ebb
xorl %r8d, %r8d
xorl %edi, %edi
cmpl %ebx, %r8d
jge 0x44e7b
shlq $0x8, %rdi
movzbl (%r14,%r8), %r9d
orq %r9, %rdi
incq %r8
jmp 0x44e5e
shlq $0x8, %rdi
incl %r8d
cmpl $0x3, %r8d
jb 0x44e74
pushq $0x4
popq %r9
movq %r9, %r8
subq $0x1, %r8
jb 0x44eaf
movl %edi, %r10d
andl $0x3f, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrq $0x6, %rdi
movq %r8, %r9
jmp 0x44e88
movl %ecx, %esi
movb $0x3d, (%rdx,%rsi)
decl %ecx
cmpl %ebx, %ecx
jg 0x44ea7
movb $0x0, 0x4(%rdx)
jmp 0x44ebb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq