LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x48581
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
addq $0x16538, %r14          # imm = 0x16538
leaq 0xa43a(%rip), %r12      # 0x52959
cmpb $0x0, (%r13)
je 0x48581
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x48aad
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3806c
movl %eax, %ebp
cmpb $0x3d, (%r13)
jne 0x4856f
incq %r13
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r13, %rdx
leaq 0xa3f5(%rip), %rcx      # 0x5295a
callq 0x48aad
movq %rax, %r13
jmp 0x48573
movb $0x0, (%r14)
testl $0xffff, %ebp           # imm = 0xFFFF
cmoveq %r14, %r15
jne 0x4851f
jmp 0x48584
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebx
testq %rsi, %rsi
je 0x48a9c
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3200
xorl %ebx, %ebx
testl %eax, %eax
je 0x48a9c
leaq 0x9b07(%rip), %rsi      # 0x52518
movl $0x4, %edx
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 0x48a60
cmpb $0x0, (%r13,%r12)
je 0x48a9c
addq $0x16538, %r14          # imm = 0x16538
leaq 0x96f3(%rip), %rcx      # 0x52161
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r13, %rdx
callq 0x48aad
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3080
testl %eax, %eax
jne 0x48a97
cmpb $0x0, (%r14,%r12)
je 0x48a9c
movl $0x1, %ebx
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_O1/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 0x48ae3
cmpl $0x20, %ebp
je 0x48ae3
testl %ebp, %ebp
je 0x48b1d
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
je 0x48ae8
incq %rbx
jmp 0x48ac1
cmpb $0x22, %bpl
jne 0x48b1d
incq %rbx
decq %r12
movzbl (%rbx), %eax
testl %eax, %eax
je 0x48b94
cmpl $0x22, %eax
je 0x48b94
subq $0x1, %r12
jb 0x48b94
movb %al, (%r15)
incq %r15
incq %rbx
jmp 0x48af4
movb (%rbx), %bpl
cmpb $0x21, %bpl
jb 0x48b94
decq %r12
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
jne 0x48b94
subq $0x1, %r12
jb 0x48b94
cmpb $0x25, %bpl
jne 0x48b82
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, %edx
cmovll %eax, %edx
addb %cl, %dl
movb %dl, (%r15)
addq $0x3, %rbx
jmp 0x48b88
incq %rbx
movb %bpl, (%r15)
incq %r15
movb (%rbx), %bpl
cmpb $0x20, %bpl
ja 0x48b29
movb $0x0, (%r15)
movb (%rbx), %al
testb %al, %al
je 0x48bb6
movsbl %al, %esi
movq %r14, %rdi
callq 0x3130
testq %rax, %rax
jne 0x48bb6
movb 0x1(%rbx), %al
incq %rbx
jmp 0x48b9a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9d08(%rip), %rsi      # 0x528e2
leaq 0x9941(%rip), %rcx      # 0x52522
callq 0x379ee
testl %eax, %eax
je 0x48bf8
movl 0x19214(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x48c1b
leaq 0x9cdf(%rip), %rsi      # 0x528e7
leaq 0x9913(%rip), %rcx      # 0x52522
movq %rbx, %rdi
callq 0x379ee
testl %eax, %eax
jne 0x48bea
movl 0x30(%r14), %eax
cmpq $0x1, %rax
jne 0x48c2e
leaq 0x28864(%rip), %rsi     # 0x71490
jmp 0x48c55
leaq 0x2885b(%rip), %rdx     # 0x71490
leaq 0x288c4(%rip), %rcx     # 0x71500
cmpq $0x0, 0x8(%rdx)
je 0x48c52
leaq 0x10(%rdx), %rsi
cmpq %rax, 0x10(%rdx)
movq %rsi, %rdx
jne 0x48c3c
jmp 0x48c55
movq %rcx, %rsi
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x48c7c
leaq 0x9c91(%rip), %rsi      # 0x528f6
leaq 0x98b6(%rip), %rcx      # 0x52522
movq %rbx, %rdi
callq 0x379ee
testl %eax, %eax
jne 0x48bea
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x48ca3
leaq 0x9c86(%rip), %rsi      # 0x52912
leaq 0x988f(%rip), %rcx      # 0x52522
movq %rbx, %rdi
callq 0x379ee
testl %eax, %eax
jne 0x48bea
movq 0x38(%r14), %rdx
testq %rdx, %rdx
je 0x48cca
leaq 0x9c6c(%rip), %rsi      # 0x5291f
leaq 0x9868(%rip), %rcx      # 0x52522
movq %rbx, %rdi
callq 0x379ee
testl %eax, %eax
jne 0x48bea
movq 0x40(%r14), %rdx
testq %rdx, %rdx
je 0x48cf1
leaq 0x9c58(%rip), %rsi      # 0x52932
leaq 0x9841(%rip), %rcx      # 0x52522
movq %rbx, %rdi
callq 0x379ee
testl %eax, %eax
jne 0x48bea
leaq 0x982a(%rip), %rsi      # 0x52522
movl $0x2, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x376e8
// File: /workspace/github_c_makefile_star2_O1/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 0x3a567
movq %rax, 0x19288(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a567
movq %rax, 0x19290(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f886
testq %rax, %rax
je 0x48ddc
movq %rax, %r12
movq 0x40(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x3a567
movq %rax, 0x18(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a567
movq %rax, 0x20(%r12)
movzwl %bx, %esi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x47d31
movq %rax, 0x28(%r12)
xorl %eax, %eax
jmp 0x48de1
movl $0x14, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49370
movq 0x19288(%rbx), %r14
testq %r14, %r14
je 0x49370
movq 0x19290(%rbx), %r15
testq %r15, %r15
je 0x49370
movq %r14, %rdi
callq 0x3110
movq %rax, %r12
movq %r15, %rdi
callq 0x3110
addq %r12, %rax
cmpq $0x3af, %rax            # imm = 0x3AF
ja 0x49370
movl %ebp, %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x80, %eax
jne 0x492f9
leaq 0x9651(%rip), %rcx      # 0x52948
jmp 0x4932a
cmpw $0x2, 0x2(%rbx)
jne 0x49314
btl $0x9, %ebp
leaq 0x9692(%rip), %rax      # 0x5299d
leaq 0x964b(%rip), %rcx      # 0x5295d
jmp 0x49326
btl $0x9, %ebp
leaq 0x96d6(%rip), %rax      # 0x529f5
leaq 0x969b(%rip), %rcx      # 0x529c1
cmovaeq %rax, %rcx
leaq 0x16538(%rbx), %r12
leaq 0x96d5(%rip), %rsi      # 0x52a0d
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x3350
movq %r12, %rdi
callq 0x3110
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x376e8
movl %eax, %ecx
testl %eax, %eax
je 0x4936c
movl 0x19214(%rbx), %eax
jmp 0x4936c
testl %ecx, %ecx
jne 0x493a3
movl 0x4(%rbx), %eax
testb $0x8, %al
je 0x49385
movq 0x6110(%rbx), %rcx
movq %rcx, 0x19230(%rbx)
andl $0x88, %eax
cmpl $0x80, %eax
jne 0x493ac
movq %rbx, %rdi
callq 0x47d97
testl %eax, %eax
je 0x493ac
movl 0x19214(%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movw $0x2, 0x18590(%rbx)
leaq 0x969f(%rip), %rsi      # 0x52a5b
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f71a
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x967d(%rip), %rsi      # 0x52a5b
callq 0x3f797
testl %eax, %eax
je 0x493f5
movl 0x19214(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x20, 0x5(%rbx)
je 0x49413
leaq 0x9120(%rip), %rsi      # 0x52522
movl $0x2, %edx
movq %rbx, %rdi
callq 0x376e8
testl %eax, %eax
jne 0x493e7
movl $0x288, %eax            # imm = 0x288
andl 0x4(%rbx), %eax
cmpl $0x88, %eax
jne 0x494d7
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 0x3350
movq %r14, 0x19258(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x49479
movq 0x18(%rax), %rcx
testq %rcx, %rcx
jne 0x49472
movq 0x8(%rax), %rcx
movq %rcx, 0x19260(%rbx)
movq $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
movq 0x19260(%rbx), %rdi
testq %rdi, %rdi
je 0x494cb
callq 0x3110
addq $0x3, %rax
andq $-0x4, %rax
jmp 0x494cd
xorl %eax, %eax
addq %rax, %r14
addq %r14, 0x6110(%rbx)
movl $0x280, %eax            # imm = 0x280
andl 0x4(%rbx), %eax
cmpl $0x80, %eax
jne 0x49507
xorl %edx, %edx
subl 0x19230(%rbx), %edx
andl $0x3, %edx
leaq 0x8c69(%rip), %rsi      # 0x52161
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x376e8
movw $0x8, 0x18590(%rbx)
xorl %eax, %eax
jmp 0x493ed
// File: /workspace/github_c_makefile_star2_O1/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 0x9529(%rip), %rsi      # 0x52a5b
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3a23a
testl %eax, %eax
je 0x4957a
cmpl $0x3, 0x19214(%r14)
jne 0x49566
leaq 0x9512(%rip), %rsi      # 0x52a64
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3a23a
testl %eax, %eax
je 0x49612
movl 0x19210(%r14), %eax
testl %eax, %eax
jne 0x49617
jmp 0x4961e
movq 0x80(%r14), %r12
testq %r12, %r12
je 0x49625
movq 0x18(%r12), %r15
testq %r15, %r15
jne 0x49599
movq 0x8(%r12), %r15
leaq 0x8bd0(%rip), %rsi      # 0x52170
movq %r15, %rdi
callq 0x3200
testl %eax, %eax
je 0x49633
leaq 0x8c29(%rip), %rsi      # 0x521e0
movq %r15, %rdi
callq 0x3200
testl %eax, %eax
jne 0x49625
movw $0x2, 0x2(%r14)
movq 0x38(%r12), %rdi
testq %rdi, %rdi
je 0x495d9
callq 0x3030
movl $0x28, %edi
callq 0x3280
movq %rax, 0x38(%r12)
testq %rax, %rax
je 0x49625
movaps 0xa78c(%rip), %xmm0     # 0x53d80
movups %xmm0, 0x10(%rax)
movaps 0xa771(%rip), %xmm0     # 0x53d70
movups %xmm0, (%rax)
movabsq $0x676e69646f636e, %rcx # imm = 0x676E69646F636E
movq %rcx, 0x20(%rax)
jmp 0x49625
movl $0x27, %eax
movl %eax, 0x19214(%r14)
movl 0x19214(%r14), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movw $0x1, 0x2(%r14)
movq 0x38(%r12), %rdi
testq %rdi, %rdi
je 0x49649
callq 0x3030
movl $0x2a, %edi
callq 0x3280
movq %rax, 0x38(%r12)
testq %rax, %rax
je 0x49625
movups 0xa6f6(%rip), %xmm0     # 0x53d5a
movups %xmm0, 0x1a(%rax)
movaps 0xa6e1(%rip), %xmm0     # 0x53d50
movups %xmm0, 0x10(%rax)
movaps 0xa6c6(%rip), %xmm0     # 0x53d40
movups %xmm0, (%rax)
jmp 0x49625
// File: /workspace/github_c_makefile_star2_O1/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 0x496b1
movw $0x1, 0x18588(%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x496d9
leaq 0x93af(%rip), %rsi      # 0x52a6d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4193c
testl %eax, %eax
jne 0x496f3
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x421b7
leaq 0x8f93(%rip), %rsi      # 0x52673
leaq 0x938f(%rip), %rdx      # 0x52a76
movq %rbx, %rdi
callq 0x425f4
testl %eax, %eax
je 0x496b7
movl 0x19214(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9332(%rip), %rsi      # 0x52a6d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3a23a
testl %eax, %eax
je 0x49753
movl 0x19214(%r14), %ebx
jmp 0x49768
cmpw $0x0, 0x6106(%r14)
jne 0x49768
movw $0x5, 0x18590(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49789
movl $0x0, 0x19214(%rdi)
xorl %eax, %eax
retq
movw $0x7, 0x18590(%rdi)
leaq 0x92d4(%rip), %rsi      # 0x52a6d
jmp 0x3a406
// File: /workspace/github_c_makefile_star2_O1/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 0x35b0
testl %eax, %eax
je 0x497be
cmpl $0x3, 0x19214(%rbx)
jne 0x497be
movl $0x0, 0x19214(%rbx)
cmpl $0x0, 0x19214(%rbx)
jne 0x497de
movq 0x5fb8(%rbx), %rax
testq %rax, %rax
je 0x497de
movq %rbx, %rdi
callq *%rax
movl %eax, 0x19214(%rbx)
movl 0x19214(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49932
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x49927
movq %rdi, %rbx
addq $0x185a8, %rdi          # imm = 0x185A8
movl $0x3ff, %r15d           # imm = 0x3FF
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rsi
callq 0x3070
movb $0x0, 0x189a7(%rbx)
movq %r14, %rdi
movl $0x3a, %esi
callq 0x3130
testq %rax, %rax
je 0x4986f
cmpb $0x2f, 0x1(%rax)
jne 0x4986f
movq %rax, %rcx
addq $0x3, %rcx
cmpb $0x2f, 0x2(%rax)
cmoveq %rcx, %r14
movq %r14, %rdi
callq 0x3110
cmpq %r15, %rax
cmovbq %rax, %r15
xorl %r12d, %r12d
testq %rax, %rax
je 0x498a9
movb (%r14,%r12), %al
movb %al, 0x18da8(%rbx,%r12)
movzbl (%r14,%r12), %eax
cmpl $0x2f, %eax
je 0x498a9
cmpl $0x3a, %eax
je 0x498a9
incq %r12
cmpq %r12, %r15
jne 0x49886
movb $0x0, 0x18da8(%rbx,%r12)
cmpb $0x3a, (%r14,%r12)
jne 0x498f5
leaq (%r14,%r12), %rdi
incq %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x3220
movl %eax, 0x191c8(%rbx)
leaq 0x1(%r12), %rcx
cmpq %rcx, %r15
cmovaq %r15, %rcx
leaq 0x1(%r12), %rax
cmpq %r15, %rax
jae 0x498fa
cmpb $0x2f, 0x1(%r14,%r12)
movq %rax, %r12
jne 0x498de
jmp 0x498fd
movq %r12, %rax
jmp 0x498fd
movq %rcx, %rax
cmpq %r15, %rax
jae 0x49927
cmpb $0x0, (%r14,%rax)
je 0x49927
leaq 0x189a8(%rbx), %rdi
addq %rax, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
callq 0x3070
movb $0x0, 0x18da7(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
testq %rdx, %rdx
je 0x49a40
movq %r13, %rdi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x49a40
movq %rax, %rbp
movq %r13, %rdi
callq 0x3110
leaq 0x1(%rax), %rdi
callq 0x3280
movq %rax, %r15
movq %rbp, %r14
subq %r13, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3070
movb $0x0, (%r15,%r14)
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
callq 0x49a73
cmpl $0x1c, %eax
jne 0x49a56
cmpb $0x0, (%rbp)
je 0x49a56
movl $0x0, 0x19214(%rbx)
movq %r15, %r14
subq %rbp, %r14
movq %rbp, %r13
decq %r13
movq %rbp, %r12
decq %r14
incq %r12
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x499ef
movq %r13, %rdi
movl $0x20, %esi
callq 0x3130
movq %rax, %rbp
testq %rax, %rax
jne 0x49a23
movq %r13, %rdi
callq 0x3110
movq %rax, %rbp
addq %r13, %rbp
leaq 0x1(%rbp), %rdx
subq %r12, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3070
movb $0x0, 0x1(%r14,%rbp)
jmp 0x499af
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
callq 0x49a73
jmp 0x49a5e
movq %r15, %rdi
callq 0x3030
movl 0x19214(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14d
movq %rdx, %rax
movq %rsi, %rbx
testq %rdx, %rdx
jne 0x49d37
leal 0x2(%r14), %eax
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
callq 0x39095
testq %rax, %rax
je 0x49da7
movb $0x0, (%rax)
testq %rbx, %rbx
je 0x49e22
leaq 0x9fa1(%rip), %rdx      # 0x53cf0
movq %rax, %rcx
cmpl $0x3, %r14d
jl 0x49dab
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edi
shll $0x10, %esi
shll $0x8, %edi
orl %esi, %edi
movzbl 0x2(%rbx), %esi
orq %rdi, %rsi
movl $0x5, %edi
movl %esi, %r8d
andl $0x3f, %r8d
movb (%r8,%rdx), %r8b
movb %r8b, -0x2(%rcx,%rdi)
shrq $0x6, %rsi
decq %rdi
cmpq $0x1, %rdi
ja 0x49d73
addq $0x4, %rcx
leal -0x3(%r14), %esi
addq $0x3, %rbx
cmpl $0x5, %r14d
movl %esi, %r14d
jg 0x49d58
jmp 0x49dae
xorl %eax, %eax
jmp 0x49e22
movl %r14d, %esi
movb $0x0, (%rcx)
testl %esi, %esi
jle 0x49e22
movl %esi, %esi
xorl %r8d, %r8d
xorl %edi, %edi
movq %rdi, %r9
shlq $0x8, %r9
movzbl (%rbx,%r8), %edi
orq %r9, %rdi
incq %r8
cmpl %r8d, %esi
jne 0x49dbc
cmpl $0x2, %esi
ja 0x49de5
leal -0x3(%rsi), %r8d
shlq $0x8, %rdi
incl %r8d
jne 0x49ddc
movl $0x5, %r8d
movl %edi, %r9d
andl $0x3f, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, -0x2(%rcx,%r8)
shrq $0x6, %rdi
decq %r8
cmpq $0x1, %r8
ja 0x49deb
cmpl $0x2, %esi
jg 0x49e1e
movl $0x3, %edx
movl %edx, %edi
movb $0x3d, (%rcx,%rdi)
decl %edx
cmpl %esi, %edx
jg 0x49e12
movb $0x0, 0x4(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_s2hex
SOAP_FMAC1
char*
SOAP_FMAC2
soap_s2hex(struct soap *soap, const unsigned char *s, char *t, int n)
{ register char *p;
  if (!t)
    t = (char*)soap_malloc(soap, 2 * n + 1);
  if (!t)
    return NULL;
  p = t;
  t[0] = '\0';
  if (s)
  { for (; n > 0; n--)
    { register int m = *s++;
      *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0'));
      m &= 0x0F;
      *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0'));
    }
  }
  *t++ = '\0';
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %rax
movq %rsi, %r14
testq %rdx, %rdx
jne 0x49ff1
leal 0x1(,%rbx,2), %eax
movslq %eax, %rsi
callq 0x39095
testq %rax, %rax
je 0x4a05b
movb $0x0, (%rax)
testq %r14, %r14
sete %cl
testl %ebx, %ebx
setle %dl
orb %cl, %dl
movq %rax, %rcx
jne 0x4a056
incl %ebx
movq %rax, %rcx
movb (%r14), %dl
movl $0x57, %esi
movl $0x57, %edi
cmpb $-0x60, %dl
jae 0x4a027
movl $0x30, %edi
movl %edx, %r8d
shrb $0x4, %r8b
addb %r8b, %dil
movb %dil, (%rcx)
andb $0xf, %dl
cmpb $0xa, %dl
jae 0x4a041
movl $0x30, %esi
incq %r14
addb %dl, %sil
movb %sil, 0x1(%rcx)
addq $0x2, %rcx
decl %ebx
cmpl $0x1, %ebx
jg 0x4a010
movb $0x0, (%rcx)
jmp 0x4a05d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_hex2s
SOAP_FMAC1
const char*
SOAP_FMAC2
soap_hex2s(struct soap *soap, const char *s, char *t, size_t l, int *n)
{ register const char *p;
  if (!s || !*s)
  { if (n)
      *n = 0;
    if (soap->error)
      return NULL;
    return SOAP_NON_NULL;
  }
  if (!t)
  { l = strlen(s) / 2;
    t = (char*)soap_malloc(soap, l);
  }
  if (!t)
    return NULL;
  p = t;
  while (l)
  { register int d1, d2;
    d1 = *s++;
    if (!d1)
      break;
    d2 = *s++;
    if (!d2)
      break;
    *t++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
    l--;
  }
  if (n)
    *n = (int)(t - p);
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r12
testq %rsi, %rsi
je 0x4a12e
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x4a12e
movq %rcx, %r15
movq %rdx, %rax
testq %rdx, %rdx
jne 0x4a0ac
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
shrq %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x39095
testq %rax, %rax
je 0x4a15b
movq %rax, %rcx
testq %r15, %r15
je 0x4a123
movb (%r14), %sil
testb %sil, %sil
je 0x4a11a
movb 0x1(%r14), %dl
addq $0x2, %r14
testb %dl, %dl
je 0x4a11d
movl %esi, %edi
andb $0x7, %dil
addb $0x9, %dil
cmpb $0x41, %sil
movzbl %sil, %esi
movzbl %dil, %edi
cmovll %esi, %edi
shlb $0x4, %dil
movl %edx, %esi
andb $0x7, %sil
addb $0x9, %sil
leal -0x30(%rdx), %r8d
cmpb $0x41, %dl
movzbl %r8b, %edx
movzbl %sil, %esi
cmovll %edx, %esi
addb %dil, %sil
movb %sil, (%rcx)
incq %rcx
decq %r15
movb $0x1, %dl
jmp 0x4a11f
incq %r14
xorl %edx, %edx
testb %dl, %dl
jne 0x4a0b8
testq %rbx, %rbx
je 0x4a14f
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x4a14f
testq %rbx, %rbx
je 0x4a139
movl $0x0, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x19214(%r12)
leaq 0x8016(%rip), %rcx      # 0x52161
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x4a14f
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_response
SOAP_FMAC2
soap_response(struct soap *soap, int status)
{ register size_t count;
  if (!(soap->omode & (SOAP_ENC_XML | SOAP_IO_STORE /* this tests for chunking too */))
   && (status == SOAP_HTML || status == SOAP_FILE))
    soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
  soap->status = status;
  count = soap_count_attachments(soap);
  if (soap_begin_send(soap))
    return soap->error;
#ifndef WITH_NOHTTP
  if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML))
  { register int n = soap->mode;
    soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
    if ((n & SOAP_IO) != SOAP_IO_FLUSH)
      soap->mode |= SOAP_IO_BUFFER;
    if ((soap->error = soap->fresponse(soap, status, count)))
      return soap->error;
#ifndef WITH_LEANER
    if ((n & SOAP_IO) == SOAP_IO_CHUNK)
    { if (soap_flush(soap))
        return soap->error;
    }
#endif
    soap->mode = n;
  }
#endif
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0xc(%rdi), %eax
movl %eax, %ecx
andl $0x42, %ecx
movl %esi, %edx
andl $-0x2, %edx
xorl $0x3ea, %edx            # imm = 0x3EA
orl %ecx, %edx
jne 0x4a44d
andl $-0x44, %eax
orl $0x2, %eax
movl %eax, 0xc(%rbx)
movl %ebp, 0x19210(%rbx)
movq %rbx, %rdi
callq 0x4a512
movq %rax, %r14
movq %rbx, %rdi
callq 0x3eeb0
testl %eax, %eax
je 0x4a475
movl 0x19214(%rbx), %eax
jmp 0x4a509
movl 0x4(%rbx), %r15d
movl %r15d, %r12d
andl $0x3, %r12d
cmpl $0x2, %r12d
sete %al
movl %r15d, %ecx
andl $0x40, %ecx
shrl $0x6, %ecx
orb %al, %cl
jne 0x4a507
movl %r15d, %eax
andl $0xfffffbbc, %eax       # imm = 0xFFFFFBBC
xorl %ecx, %ecx
testl %r12d, %r12d
setne %cl
orl %eax, %ecx
movl %ecx, 0x4(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq *0x5fa0(%rbx)
movl %eax, 0x19214(%rbx)
testl %eax, %eax
je 0x4a4c5
xorl %ecx, %ecx
jmp 0x4a503
cmpl $0x3, %r12d
jne 0x4a4fd
movq 0x60f0(%rbx), %rdx
testq %rdx, %rdx
je 0x4a4fd
movq $0x0, 0x60f0(%rbx)
leaq 0x6138(%rbx), %rsi
movq %rbx, %rdi
callq 0x37839
testl %eax, %eax
je 0x4a4fd
movl 0x19214(%rbx), %eax
jmp 0x4a4c1
movl %r15d, 0x4(%rbx)
movb $0x1, %cl
testb %cl, %cl
je 0x4a509
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_validation_fault
static const char*
soap_set_validation_fault(struct soap *soap, const char *s, const char *t)
{ if (*soap->tag)
    sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element '%s'", s, t?t:SOAP_STR_EOS, soap->tag);
  else
    sprintf(soap->msgbuf, "Validation constraint violation: %s%s", s, t?t:SOAP_STR_EOS);
  return soap->msgbuf;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
leaq 0x16138(%rdi), %rbx
testq %rax, %rax
leaq 0x767c(%rip), %rcx      # 0x52161
cmovneq %rax, %rcx
cmpb $0x0, 0x16938(%rdi)
je 0x4ab0f
movq %rdi, %r8
addq $0x16938, %r8           # imm = 0x16938
leaq 0x8f1a(%rip), %rsi      # 0x53a1d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
jmp 0x4ab20
leaq 0x8f3d(%rip), %rsi      # 0x53a53
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_strerror
static const char*
soap_strerror(struct soap *soap)
{ register int err = soap->errnum;
  if (err)
  {
#ifndef WIN32
    return strerror(err);
#else
#ifndef UNDER_CE
    DWORD len;
    *soap->msgbuf = '\0';
    len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)soap->msgbuf, (DWORD)sizeof(soap->msgbuf), NULL);
#else
    DWORD i, len;
    *soap->msgbuf = '\0';
    len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
    for (i = 0; i <= len; i++)
    { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
        soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
      else
        soap->msgbuf[i] = '?';
    }
#endif
#endif
  }
  else
  { char *s = soap->msgbuf;
#ifndef WITH_LEAN
    int rt = soap->recv_timeout, st = soap->send_timeout;
    int ru = ' ', su = ' ';
#endif
    strcpy(s, "Operation interrupted or timed out");
#ifndef WITH_LEAN
    if (rt < 0)
    { rt = -rt;
      ru = 'u';
    }
    if (st < 0)
    { st = -st;
      su = 'u';
    }
    if (rt)
      sprintf(s + strlen(s), " (%d%cs receive delay)", rt, ru);
    if (st)
      sprintf(s + strlen(s), " (%d%cs send delay)", st, su);
#endif
  }
  return soap->msgbuf;
}

// Assembly:
movl 0x1921c(%rdi), %eax
testl %eax, %eax
je 0x4ab36
movl %eax, %edi
jmp 0x3390
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x16138(%rdi), %rbx
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %r13d
movups 0x9149(%rip), %xmm0     # 0x53c9f
movups %xmm0, 0x16138(%rdi)
movups 0x914b(%rip), %xmm0     # 0x53caf
movups %xmm0, 0x16148(%rdi)
movl %r13d, %ebp
negl %ebp
cmovsl %r13d, %ebp
movl $0x74756f, 0x16157(%rdi) # imm = 0x74756F
testl %r13d, %r13d
movl $0x75, %ecx
movl $0x20, %r15d
movl $0x20, %r14d
cmovsl %ecx, %r14d
testl %eax, %eax
je 0x4abca
movl %eax, %r12d
negl %r12d
cmovsl %eax, %r12d
testl %eax, %eax
cmovsl %ecx, %r15d
movq %rbx, %rdi
callq 0x3110
leaq (%rax,%rbx), %rdi
leaq 0x9105(%rip), %rsi      # 0x53cc2
movl %r12d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x3350
testl %r13d, %r13d
je 0x4abee
movq %rbx, %rdi
callq 0x3110
leaq (%rax,%rbx), %rdi
leaq 0x90f7(%rip), %rsi      # 0x53cd9
movl %ebp, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3350
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_send_empty_response
SOAP_FMAC2
soap_send_empty_response(struct soap *soap, int httpstatuscode)
{ register soap_mode m = soap->omode;
  soap->count = 0;
  if ((m & SOAP_IO) == SOAP_IO_CHUNK)
    soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
  if (soap_response(soap, httpstatuscode) || soap_end_send(soap))
  { soap->omode = m;
    return soap_closesock(soap);
  }
  soap->omode = m;
  return soap->error = SOAP_STOP; /* stops the server's response */
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %ebp
movq $0x0, 0x6110(%rdi)
movl %ebp, %eax
notl %eax
testb $0x3, %al
jne 0x4afdc
movl %ebp, %eax
andl $-0x3, %eax
movl %eax, 0xc(%rbx)
movq %rbx, %rdi
callq 0x4a420
testl %eax, %eax
jne 0x4aff4
movq %rbx, %rdi
callq 0x40148
testl %eax, %eax
je 0x4b005
movl %ebp, 0xc(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ba2e
movl %ebp, 0xc(%rbx)
movl $0x3e8, 0x19214(%rbx)   # imm = 0x3E8
movl $0x3e8, %eax            # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_recv_empty_response
SOAP_FMAC2
soap_recv_empty_response(struct soap *soap)
{ if (!soap_begin_recv(soap))
    soap_end_recv(soap);
  else if (soap->error == SOAP_NO_DATA || soap->error == 202)
    soap->error = SOAP_OK;
  return soap_closesock(soap);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x48dfc
testl %eax, %eax
je 0x4b049
movl 0x19214(%rbx), %eax
cmpl $0xca, %eax
je 0x4b03d
cmpl $0xe, %eax
jne 0x4b051
movl $0x0, 0x19214(%rbx)
jmp 0x4b051
movq %rbx, %rdi
callq 0x40815
movq %rbx, %rdi
popq %rbx
jmp 0x3ba2e
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_set_error
static int
soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
{ *soap_faultcode(soap) = faultcode;
  if (faultsubcodeQName)
    *soap_faultsubcode(soap) = faultsubcodeQName;
  *soap_faultstring(soap) = faultstring;
  if (faultdetailXML && *faultdetailXML)
  { register const char **s = soap_faultdetail(soap);
    if (s)
      *s = faultdetailXML;
  }
  return soap->error = soaperror;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
callq 0x396c
movq %rbp, (%rax)
testq %r13, %r13
je 0x4b08f
movq %r15, %rdi
callq 0x398f
movq %r13, (%rax)
movq %r15, %rdi
callq 0x39ef
movq %r12, (%rax)
testq %r14, %r14
je 0x4b0b5
cmpb $0x0, (%r14)
je 0x4b0b5
movq %r15, %rdi
callq 0x3a12
testq %rax, %rax
je 0x4b0b5
movq %r14, (%rax)
movl %ebx, 0x19214(%r15)
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_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_copy_fault
static int
soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
{ char *r = NULL, *s = NULL, *t = NULL;
  if (faultsubcodeQName)
    r = soap_strdup(soap, faultsubcodeQName);
  if (faultstring)
    s = soap_strdup(soap, faultstring);
  if (faultdetailXML)
    t = soap_strdup(soap, faultdetailXML);
  return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4b13a
movq %r14, %rdi
movq %rdx, %rsi
callq 0x3a567
movq %rax, %r15
jmp 0x4b13d
xorl %r15d, %r15d
testq %r13, %r13
je 0x4b152
movq %r14, %rdi
movq %r13, %rsi
callq 0x3a567
movq %rax, %r13
jmp 0x4b155
xorl %r13d, %r13d
testq %r12, %r12
je 0x4b16a
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a567
movq %rax, %r8
jmp 0x4b16d
xorl %r8d, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
movl $0xc, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4b05a
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_print_fault
SOAP_FMAC2
soap_print_fault(struct soap *soap, FILE *fd)
{ if (soap_check_state(soap))
    fprintf(fd, "Error: soap struct state not initialized\n");
  else if (soap->error)
  { const char *c, *v = NULL, *s, **d;
    d = soap_faultcode(soap);
    if (!*d)
      soap_set_fault(soap);
    c = *d;
    if (soap->version == 2)
      v = *soap_faultsubcode(soap);
    s = *soap_faultstring(soap);
    d = soap_faultdetail(soap);
    fprintf(fd, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c, v ? v : "no subcode", s ? s : "[no reason]", d && *d ? *d : "[no detail]");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4b233
movq %rdi, %r15
movl (%rdi), %eax
decl %eax
cmpw $0x2, %ax
jae 0x4b233
cmpl $0x0, 0x19214(%r15)
je 0x4b2e4
movq %r15, %rdi
callq 0x396c
movq %rax, %r14
cmpq $0x0, (%rax)
jne 0x4b21b
movq %r15, %rdi
callq 0x4a6b7
movq (%r14), %r14
cmpw $0x2, 0x2(%r15)
jne 0x4b255
movq %r15, %rdi
callq 0x398f
movq (%rax), %r12
jmp 0x4b258
leaq 0x7f5c(%rip), %rdi      # 0x53196
movl $0x29, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3370
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x39ef
movq (%rax), %r13
movq %r15, %rdi
callq 0x3a12
movswl 0x2(%r15), %ecx
leaq 0x7f76(%rip), %rsi      # 0x531ed
leaq 0x7f67(%rip), %rdx      # 0x531e5
testl %ecx, %ecx
cmoveq %rsi, %rdx
jne 0x4b28d
movl 0x19214(%r15), %ecx
testq %r12, %r12
leaq 0x7f5d(%rip), %r9       # 0x531f4
cmovneq %r12, %r9
testq %r13, %r13
leaq 0x7f5a(%rip), %r10      # 0x531ff
cmovneq %r13, %r10
testq %rax, %rax
je 0x4b2c1
movq (%rax), %rax
testq %rax, %rax
leaq 0x7f50(%rip), %r11      # 0x5320b
cmovneq %rax, %r11
jmp 0x4b2c8
leaq 0x7f43(%rip), %r11      # 0x5320b
leaq 0x7ef1(%rip), %rsi      # 0x531c0
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x3210
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/loversmile[P]sugarcrm/sugar_stdsoap2.c
// Function: soap_sprint_fault
SOAP_FMAC1
char*
SOAP_FMAC2
soap_sprint_fault(struct soap *soap, char *buf, size_t len)
{ if (soap_check_state(soap))
    strncpy(buf, "Error: soap struct not initialized", len);
  else if (soap->error)
  { const char *c, *v = NULL, *s, **d;
    d = soap_faultcode(soap);
    if (!*d)
      soap_set_fault(soap);
    c = *d;
    if (soap->version == 2)
      v = *soap_faultsubcode(soap);
    s = *soap_faultstring(soap);
    d = soap_faultdetail(soap);
#ifdef HAVE_SNPRINTF
# ifdef WIN32
    _snprintf
# else
    snprintf
# endif
      (buf, len, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c, v ? v : "no subcode", s ? s : "[no reason]", d && *d ? *d : "[no detail]");
#else
    if (len > 40 + (v ? strlen(v) : 0) + (s ? strlen(s) : 0) + (d && *d ? strlen(*d) : 0))
      sprintf(buf, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c, v ? v : "no subcode", s ? s : "[no reason]", d && *d ? *d : "[no detail]");
    else if (len > 40)
      sprintf(buf, "%s%d fault: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c);
    else
      buf[0] = '\0';
#endif
  }
  return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4b352
movq %rdi, %r12
movl (%rdi), %eax
decl %eax
cmpw $0x2, %ax
jae 0x4b352
cmpl $0x0, 0x19214(%r12)
je 0x4b40d
movq %r12, %rdi
callq 0x396c
movq %rax, %r15
cmpq $0x0, (%rax)
jne 0x4b339
movq %r12, %rdi
callq 0x4a6b7
movq (%r15), %r15
cmpw $0x2, 0x2(%r12)
jne 0x4b372
movq %r12, %rdi
callq 0x398f
movq (%rax), %r13
jmp 0x4b375
leaq 0x7ebe(%rip), %rsi      # 0x53217
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3070
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x39ef
movq (%rax), %rbp
movq %r12, %rdi
callq 0x3a12
movswl 0x2(%r12), %r8d
leaq 0x7e58(%rip), %rdx      # 0x531ed
leaq 0x7e49(%rip), %rcx      # 0x531e5
testl %r8d, %r8d
cmoveq %rdx, %rcx
jne 0x4b3ad
movl 0x19214(%r12), %r8d
testq %r13, %r13
leaq 0x7e3d(%rip), %r10      # 0x531f4
cmovneq %r13, %r10
testq %rbp, %rbp
leaq 0x7e3a(%rip), %r11      # 0x531ff
cmovneq %rbp, %r11
testq %rax, %rax
je 0x4b3e1
movq (%rax), %rax
testq %rax, %rax
leaq 0x7e30(%rip), %r12      # 0x5320b
cmovneq %rax, %r12
jmp 0x4b3e8
leaq 0x7e23(%rip), %r12      # 0x5320b
subq $0x8, %rsp
leaq 0x7dcd(%rip), %rdx      # 0x531c0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r9
xorl %eax, %eax
pushq %r12
pushq %r11
pushq %r10
callq 0x3150
addq $0x20, %rsp
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq