LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_infloat
SOAP_FMAC1
float *
SOAP_FMAC2
soap_infloat(struct soap *soap, const char *tag, float *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type != '\0' && soap_isnumeric(soap, type))
    return NULL;
#endif
  p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (float*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(float), 0, NULL);
  else if (p)
  { if (soap_s2float(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, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12e5d
testl %eax, %eax
jne 0x1e4d1
cmpb $0x0, 0x1d598(%r14)
je 0x1e423
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e4e8
testl %eax, %eax
jne 0x1e4ce
leaq 0x1cd98(%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x4, %r8d
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%r14)
je 0x1e4af
leaq 0x1d198(%r14), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x4, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%r14)
je 0x1e4d1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1e4ce
jmp 0x1e4d1
testq %r15, %r15
je 0x1e4e3
movq %r14, %rdi
callq 0x1d668
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e2dd
testl %eax, %eax
je 0x1e493
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 0x1e493
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_double2s
SOAP_FMAC1
const char*
SOAP_FMAC2
soap_double2s(struct soap *soap, double n)
{ char *s;
  if (soap_isnan(n))
    return "NaN";
  if (soap_ispinfd(n))
    return "INF";
  if (soap_isninfd(n))
    return "-INF";
  s = soap->tmpbuf;
#if defined(HAVE_SPRINTF_L)
  sprintf_l(s, soap->c_locale, soap->double_format, n);
#else
  sprintf(s, soap->double_format, n);
  s = strchr(s, ',');	/* convert decimal comma to DP */
  if (s)
    *s = '.';
#endif
  return soap->tmpbuf;
}

// Assembly:
pushq %rbx
ucomisd %xmm0, %xmm0
jp 0x1e74a
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm0, %xmm1
subsd %xmm0, %xmm1
jbe 0x1e706
ucomisd %xmm1, %xmm1
jnp 0x1e706
leaq 0x7f59(%rip), %rbx      # 0x2665d
jmp 0x1e745
ucomisd %xmm0, %xmm2
jbe 0x1e71b
ucomisd %xmm1, %xmm1
jnp 0x1e71b
leaq 0x7f3e(%rip), %rbx      # 0x26657
jmp 0x1e745
movq 0x18(%rbx), %rsi
addq $0x1c598, %rbx          # imm = 0x1C598
movq %rbx, %rdi
movb $0x1, %al
callq 0x3300
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x3130
testq %rax, %rax
je 0x1e745
movb $0x2e, (%rax)
movq %rbx, %rax
popq %rbx
retq
leaq 0x7f02(%rip), %rbx      # 0x26653
jmp 0x1e745
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_outdouble
SOAP_FMAC2
soap_outdouble(struct soap *soap, const char *tag, int id, const double *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_double2s(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 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x1e7a6
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x1e6db
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x1e7b9
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_s2double
SOAP_FMAC2
soap_s2double(struct soap *soap, const char *s, double *p)
{ if (s)
  { if (!*s)
      return soap->error = SOAP_TYPE;
    if (!soap_tag_cmp(s, "INF"))
      *p = DBL_PINFTY;
    else if (!soap_tag_cmp(s, "+INF"))
      *p = DBL_PINFTY;
    else if (!soap_tag_cmp(s, "-INF"))
      *p = DBL_NINFTY;
    else if (!soap_tag_cmp(s, "NaN"))
      *p = DBL_NAN;
    else
    {
#if defined(HAVE_STRTOD_L)
      char *r;
      *p = strtod_l(s, &r, soap->c_locale);
      if (*r)
#elif defined(HAVE_STRTOD)
      char *r;
      *p = strtod(s, &r);
      if (*r)
#endif
      {
#if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
        if (sscanf_l(s, soap->c_locale, "%lg", p) != 1)
          soap->error = SOAP_TYPE;
#elif defined(HAVE_SSCANF)
        if (sscanf(s, "%lg", p) != 1)
          soap->error = SOAP_TYPE;
#else
        soap->error = SOAP_TYPE;
#endif
      }
    }
  }
  return soap->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1e890
movq %rsi, %r15
cmpb $0x0, (%rsi)
je 0x1e898
movq %rdx, %r14
leaq 0x7e64(%rip), %rsi      # 0x2665d
movq %r15, %rdi
callq 0x10d19
testl %eax, %eax
je 0x1e883
leaq 0x7e50(%rip), %rsi      # 0x2665c
movq %r15, %rdi
callq 0x10d19
testl %eax, %eax
je 0x1e883
leaq 0x7e38(%rip), %rsi      # 0x26657
movq %r15, %rdi
callq 0x10d19
testl %eax, %eax
je 0x1e8b3
leaq 0x7e1d(%rip), %rsi      # 0x26653
movq %r15, %rdi
callq 0x10d19
testl %eax, %eax
je 0x1e8bf
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30a0
movsd %xmm0, (%r14)
movq (%r12), %rax
cmpb $0x0, (%rax)
je 0x1e890
leaq 0x7dff(%rip), %rsi      # 0x26664
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3250
cmpl $0x1, %eax
je 0x1e890
movl $0x4, 0x1f274(%rbx)
jmp 0x1e890
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rax, (%r14)
movl 0x1f274(%rbx), %eax
jmp 0x1e8a7
movl $0x4, 0x1f274(%rbx)
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
jmp 0x1e88d
movq $-0x1, (%r14)
jmp 0x1e890
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_indouble
SOAP_FMAC1
double *
SOAP_FMAC2
soap_indouble(struct soap *soap, const char *tag, double *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type != '\0' && soap_isnumeric(soap, type))
    return NULL;
#endif
  p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (double*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(double), 0, NULL);
  else if (p)
  { if (soap_s2double(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, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12e5d
testl %eax, %eax
jne 0x1e9c4
cmpb $0x0, 0x1d598(%r14)
je 0x1e916
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e4e8
testl %eax, %eax
jne 0x1e9c1
leaq 0x1cd98(%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x8, %r8d
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%r14)
je 0x1e9a2
leaq 0x1d198(%r14), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x8, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%r14)
je 0x1e9c4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1e9c1
jmp 0x1e9c4
testq %r15, %r15
je 0x1e9d6
movq %r14, %rdi
callq 0x1d668
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e7cf
testl %eax, %eax
je 0x1e986
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 0x1e986
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_outunsignedByte
SOAP_FMAC2
soap_outunsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *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_unsignedLong2s(soap, (unsigned long)*p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x1ea7e
movzbl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x7c22(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x1ea91
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_inunsignedByte
SOAP_FMAC1
unsigned char *
SOAP_FMAC2
soap_inunsignedByte(struct soap *soap, const char *tag, unsigned char *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":unsignedByte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned char), 0, NULL);
  else if (p)
  { if (soap_s2unsignedByte(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 0x12e5d
testl %eax, %eax
jne 0x1ec5d
cmpb $0x0, 0x1d598(%rbx)
je 0x1ebb1
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x140fd
testl %eax, %eax
je 0x1ebb1
leaq 0x7b00(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1ebb1
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1ec5a
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1ec5a
decl 0xc168(%rbx)
jmp 0x1ec5a
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, %r8d
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1ec3b
leaq 0x1d198(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x1, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1ec5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1ec5a
jmp 0x1ec5d
testq %r15, %r15
je 0x1ec6f
movq %rbx, %rdi
callq 0x1d668
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1eaa7
testl %eax, %eax
je 0x1ec20
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 0x1ec20
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_outunsignedShort
SOAP_FMAC2
soap_outunsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *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_unsignedLong2s(soap, (unsigned long)*p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x1ecf6
movzwl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x79aa(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x1ed09
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_inunsignedShort
SOAP_FMAC1
unsigned short *
SOAP_FMAC2
soap_inunsignedShort(struct soap *soap, const char *tag, unsigned short *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":unsignedShort")
   && soap_match_tag(soap, soap->type, ":unsignedByte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned short), 0, NULL);
  else if (p)
  { if (soap_s2unsignedShort(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 0x12e5d
testl %eax, %eax
jne 0x1eeec
cmpb $0x0, 0x1d598(%rbx)
je 0x1ee40
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x140fd
testl %eax, %eax
je 0x1ee40
leaq 0x7895(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1ee40
leaq 0x7871(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1ee40
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1eee9
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1eee9
decl 0xc168(%rbx)
jmp 0x1eee9
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x2, %r8d
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1eeca
leaq 0x1d198(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x2, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1eeec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1eee9
jmp 0x1eeec
testq %r15, %r15
je 0x1eefe
movq %rbx, %rdi
callq 0x1d668
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1ed1f
testl %eax, %eax
je 0x1eeaf
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 0x1eeaf
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_outunsignedInt
SOAP_FMAC2
soap_outunsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *p, const char *type, int n)
{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
   || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
    return soap->error;
  return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x1ef84
movl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x771c(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x1ef97
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_s2unsignedInt
SOAP_FMAC2
soap_s2unsignedInt(struct soap *soap, const char *s, unsigned int *p)
{ if (s)
  { char *r;
#ifndef WITH_NOIO
#ifndef WITH_LEAN
    soap_reset_errno;
#endif
#endif
    *p = (unsigned int)soap_strtoul(s, &r, 10);
    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
#ifndef WITH_NOIO
#ifndef WITH_LEAN
     || soap_errno == SOAP_ERANGE
#endif
#endif
    )
      soap->error = SOAP_TYPE;
  }
  return soap->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1f013
movq %rdx, %r12
movq %rsi, %r15
callq 0x3050
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x32e0
movl %eax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x1effe
testb $0x10, 0x5(%rbx)
jne 0x1f009
cmpb $0x0, (%rax)
jne 0x1f009
cmpl $0x22, (%r14)
jne 0x1f013
movl $0x4, 0x1f274(%rbx)
movl 0x1f274(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_inunsignedInt
SOAP_FMAC1
unsigned int *
SOAP_FMAC2
soap_inunsignedInt(struct soap *soap, const char *tag, unsigned int *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":unsignedInt")
   && soap_match_tag(soap, soap->type, ":unsignedShort")
   && soap_match_tag(soap, soap->type, ":unsignedByte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned int), 0, NULL);
  else if (p)
  { if (soap_s2unsignedInt(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 0x12e5d
testl %eax, %eax
jne 0x1f1a6
cmpb $0x0, 0x1d598(%rbx)
je 0x1f0fa
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x140fd
testl %eax, %eax
je 0x1f0fa
leaq 0x64ce(%rip), %rdx      # 0x25553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f0fa
leaq 0x75db(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f0fa
leaq 0x75b7(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f0fa
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1f1a3
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1f1a3
decl 0xc168(%rbx)
jmp 0x1f1a3
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x4, %r8d
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1f184
leaq 0x1d198(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x4, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1f1a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1f1a3
jmp 0x1f1a6
testq %r15, %r15
je 0x1f1b8
movq %rbx, %rdi
callq 0x1d668
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1efad
testl %eax, %eax
je 0x1f169
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 0x1f169
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_s2unsignedLong
SOAP_FMAC2
soap_s2unsignedLong(struct soap *soap, const char *s, unsigned long *p)
{ if (s)
  { char *r;
#ifndef WITH_NOIO
#ifndef WITH_LEAN
    soap_reset_errno;
#endif
#endif
    *p = soap_strtoul(s, &r, 10);
    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
#ifndef WITH_NOIO
#ifndef WITH_LEAN
     || soap_errno == SOAP_ERANGE
#endif
#endif
    )
      soap->error = SOAP_TYPE;
  }
  return soap->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1f2ad
movq %rdx, %r12
movq %rsi, %r15
callq 0x3050
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x32e0
movq %rax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x1f298
testb $0x10, 0x5(%rbx)
jne 0x1f2a3
cmpb $0x0, (%rax)
jne 0x1f2a3
cmpl $0x22, (%r14)
jne 0x1f2ad
movl $0x4, 0x1f274(%rbx)
movl 0x1f274(%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_inunsignedLong
SOAP_FMAC1
unsigned long *
SOAP_FMAC2
soap_inunsignedLong(struct soap *soap, const char *tag, unsigned long *p, const char *type, int t)
{ if (soap_element_begin_in(soap, tag, 0, NULL))
    return NULL;
#ifndef WITH_LEAN
  if (*soap->type
   && soap_match_tag(soap, soap->type, type)
   && soap_match_tag(soap, soap->type, ":unsignedInt")
   && soap_match_tag(soap, soap->type, ":unsignedShort")
   && soap_match_tag(soap, soap->type, ":unsignedByte"))
  { soap->error = SOAP_TYPE;
    soap_revert(soap);
    return NULL;
  }
#endif
  p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), 0, NULL, NULL, NULL);
  if (*soap->href)
    p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned long), 0, NULL);
  else if (p)
  { if (soap_s2unsignedLong(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 0x12e5d
testl %eax, %eax
jne 0x1f440
cmpb $0x0, 0x1d598(%rbx)
je 0x1f394
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x140fd
testl %eax, %eax
je 0x1f394
leaq 0x6234(%rip), %rdx      # 0x25553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f394
leaq 0x7341(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f394
leaq 0x731d(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140fd
testl %eax, %eax
je 0x1f394
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1f43d
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1f43d
decl 0xc168(%rbx)
jmp 0x1f43d
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x8, %r8d
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x18f76
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1f41e
leaq 0x1d198(%rbx), %rsi
movq $0x0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x8, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18e29
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1f440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
jne 0x1f43d
jmp 0x1f440
testq %r15, %r15
je 0x1f452
movq %rbx, %rdi
callq 0x1d668
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1f247
testl %eax, %eax
je 0x1f403
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 0x1f403
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_outULONG64
SOAP_FMAC2
soap_outULONG64(struct soap *soap, const char *tag, int id, const ULONG64 *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_ULONG642s(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 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x1f4d9
movq (%r15), %rdx
leaq 0x1c598(%r14), %r15
leaq 0x71c7(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x1f4ec
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x3280
movq %rax, 0x8(%rsp)
movq $-0x1, %rbx
cmpq $-0x1, %rax
je 0x2000e
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x3170
movl $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x3280
cmpq $-0x1, %rax
je 0x2000e
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_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x200ca
movq (%r15), %rsi
movq %r14, %rdi
callq 0x20019
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1b965
testl %eax, %eax
je 0x200dd
movl 0x1f274(%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 0x18722
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x20b05
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 0x11c92
testq %rax, %rax
je 0x20b05
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 0x3080
jmp 0x20b07
xorl %ebp, %ebp
movq %rbp, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x20ee2
movq %rsi, %r15
movq %rdi, %rbx
incq %rsi
callq 0x11c92
testq %rax, %rax
je 0x20ee7
movq %rax, %r14
xorl %r12d, %r12d
movq 0xc150(%rbx), %rax
cmpq 0xc158(%rbx), %rax
jb 0x20e99
movq %rbx, %rdi
callq 0x109c7
testl %eax, %eax
jne 0x20eee
movq 0xc150(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc150(%rbx)
movb 0xc198(%rbx,%rax), %al
movb %al, (%r14,%r12)
incq %r12
cmpq %r12, %r15
jne 0x20e76
movb $0x0, (%r14,%r12)
negl %r15d
andl $0x3, %r15d
je 0x20ede
incq %r15
movq %rbx, %rdi
callq 0x10c37
cmpl $-0x1, %eax
je 0x20eee
decq %r15
cmpq $0x2, %r15
jge 0x20ec8
xorl %eax, %eax
jmp 0x20ef6
xorl %r14d, %r14d
jmp 0x20efc
movl $0x14, %eax
jmp 0x20ef3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movl %eax, 0x1f274(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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, 0x1f300(%rdi)
callq 0x13199
movq %rax, 0x1f2e8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13199
movq %rax, 0x1f2f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_begin_serve
SOAP_FMAC2
soap_begin_serve(struct soap *soap)
{
#ifdef WITH_FASTCGI
  if (FCGI_Accept() < 0)
  { soap->error = SOAP_EOF;
    return soap_send_fault(soap);
  }
#endif
  soap_begin(soap);
  if (soap_begin_recv(soap))
  { if (soap->error < SOAP_STOP)
    {
#ifdef WITH_FASTCGI
      soap_send_fault(soap);
#else
      return soap_send_fault(soap);
#endif
    }
    return soap_closesock(soap);
  }
  if (soap_envelope_begin_in(soap)
   || soap_recv_header(soap)
   || soap_body_begin_in(soap))
    return soap->error;
  return SOAP_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a780
movq %rbx, %rdi
callq 0x219ea
testl %eax, %eax
je 0x219b1
cmpl $0x3e7, 0x1f274(%rbx)   # imm = 0x3E7
jg 0x219dd
movq %rbx, %rdi
popq %rbx
jmp 0x2202f
movq %rbx, %rdi
callq 0x2221a
testl %eax, %eax
jne 0x219d5
movq %rbx, %rdi
callq 0x22397
testl %eax, %eax
jne 0x219d5
movq %rbx, %rdi
callq 0x223e5
testl %eax, %eax
je 0x219e6
movl 0x1f274(%rbx), %eax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x14730
xorl %eax, %eax
jmp 0x219db
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x3909
testl %eax, %eax
setne %cl
movl 0x1f274(%rbx), %eax
cmpl $0x3, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x223c4
movl $0x0, 0x1f274(%rbx)
jmp 0x223c8
testl %eax, %eax
jne 0x223e3
movq 0xbfe0(%rbx), %rax
testq %rax, %rax
je 0x223e1
movq %rbx, %rdi
callq *%rax
movl %eax, 0x1f274(%rbx)
jmp 0x223e3
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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, 0x1e5f0(%rdi)
leaq 0x4521(%rip), %rsi      # 0x2691d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12e5d
testl %eax, %eax
je 0x22414
movl 0x1f274(%r14), %ebx
jmp 0x22429
cmpw $0x0, 0xc166(%r14)
jne 0x22429
movw $0x5, 0x1e5f0(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_envelope_end_out
SOAP_FMAC2
soap_envelope_end_out(struct soap *soap)
{
	//(2011-8-9 duwenyong)modify����Envelope�󲻷���"\r\n"�����ַ���
	//���򺣿�DS-2CD863PF(NF)-E(W) �᷵��matching rule specified is not supported.
  //if (soap_element_end_out(soap, "SOAP-ENV:Envelope") || soap_send_raw(soap, "\r\n", 2))	/* 2.8: always emit \r\n after SOAP Envelope */
  if (soap_element_end_out(soap, "SOAP-ENV:Envelope"))	/* 2.8: always emit \r\n after SOAP Envelope */
    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 0x4394(%rip), %rsi      # 0x2690b
callq 0x18722
testl %eax, %eax
je 0x2258b
movl 0x1f274(%rbx), %eax
jmp 0x22691
movl 0x4(%rbx), %eax
movl %eax, %ecx
andl $0x288, %ecx            # imm = 0x288
cmpl $0x88, %ecx
jne 0x2265b
movq 0xc170(%rbx), %rax
subq 0x1f290(%rbx), %rax
movq %rax, 0x1f290(%rbx)
leaq 0x1cd98(%rbx), %r14
movq 0x20(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3300
movq %r14, 0x1f2b8(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x225f7
movq 0x18(%rax), %r15
testq %r15, %r15
jne 0x225ee
movq 0x8(%rax), %r15
movq %r15, 0x1f2c0(%rbx)
jmp 0x225fe
movq 0x1f2c0(%rbx), %r15
movq $0x0, 0x1f2c8(%rbx)
cmpq $0x0, 0x1f2d8(%rbx)
sete %al
addb %al, %al
orb $0x24, %al
movb %al, 0x1f2a8(%rbx)
movq %r14, %rdi
callq 0x3110
movq %rax, %r14
addq $0x3, %r14
andq $-0x4, %r14
addq $0xc, %r14
testq %r15, %r15
je 0x2264c
movq %r15, %rdi
callq 0x3110
addq $0x3, %rax
andq $-0x4, %rax
jmp 0x2264e
xorl %eax, %eax
addq %rax, %r14
addq %r14, 0xc170(%rbx)
movl 0x4(%rbx), %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x80, %eax
jne 0x22686
xorl %edx, %edx
subl 0x1f290(%rbx), %edx
andl $0x3, %edx
leaq 0x3948(%rip), %rsi      # 0x25fc1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x102b0
movw $0x8, 0x1e5f0(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_get_http_body
SOAP_FMAC1
char*
SOAP_FMAC2
soap_get_http_body(struct soap *soap)
{
#ifndef WITH_LEAN
  register size_t l = 0, n = 0;
  register char *s;
  /* get HTML body of HTTP error content */
  if (!(soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK)
  { n = soap->length;
    if (!n)
      return NULL;
  }
#ifdef WITH_FAST
  soap->labidx = 0;			/* use look-aside buffer */
#else
  if (soap_new_block(soap) == NULL)
    return NULL;
#endif
  for (;;)
  {
#ifdef WITH_FAST
    register size_t i, k;
    if (soap_append_lab(soap, NULL, 0))	/* allocate more space in look-aside buffer if necessary */
      return NULL;
    s = soap->labbuf + soap->labidx;	/* space to populate */
    k = soap->lablen - soap->labidx;	/* number of bytes available */
    soap->labidx = soap->lablen;	/* claim this space */
#else
    register size_t i, k = SOAP_BLKLEN;
    if (!(s = (char*)soap_push_block(soap, NULL, k)))
      return NULL;
#endif
    for (i = 0; i < k; i++)
    { register soap_wchar c;
      l++;
      if (n > 0 && l > n)
        goto end;
      c = soap_getchar(soap);
      if ((int)c == EOF)
        goto end;
      *s++ = (char)(c & 0xFF);
    }
  }
end:
  *s = '\0';
#ifdef WITH_FAST
  s = soap_strdup(soap, soap->labbuf);
#else
  soap_size_block(soap, NULL, i+1);
  s = soap_save_block(soap, NULL, 0);
#endif
  return s;
#else
  return NULL;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
notl %eax
testb $0x3, %al
sete %al
orb %cl, %al
je 0x226c0
xorl %r14d, %r14d
jmp 0x226cc
movq 0xc178(%rbx), %r14
testq %r14, %r14
je 0x226e7
movq $0x0, 0xc190(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11bb5
testl %eax, %eax
je 0x226f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq 0xc180(%rbx), %r12
movq 0xc188(%rbx), %r13
movq 0xc190(%rbx), %rax
movq %r13, %rbp
movq %r13, 0xc190(%rbx)
subq %rax, %rbp
je 0x2275f
addq %rax, %r12
addq %r15, %r13
subq %rax, %r13
incq %r15
movq %r15, (%rsp)
xorl %r15d, %r15d
testq %r14, %r14
je 0x22743
movq (%rsp), %rax
addq %r15, %rax
cmpq %r14, %rax
ja 0x22774
movq %rbx, %rdi
callq 0x10c37
cmpl $-0x1, %eax
je 0x22774
movb %al, (%r12,%r15)
incq %r15
cmpq %r15, %rbp
jne 0x22732
movq %r13, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11bb5
testl %eax, %eax
je 0x226fb
jmp 0x226e7
movb $0x0, (%r15,%r12)
movq 0xc180(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13199
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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_SEC_WSUID) && soap_set_attr(soap, "wsu:Id", "Body", 1))
    return soap->error;
#endif
  return soap_element_begin_out(soap, "SOAP-ENV:Body", 0, NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movw $0x6, 0x1e5f0(%rdi)
cmpw $0x1, 0x2(%rdi)
jne 0x227c8
movw $0x1, 0x1e5e8(%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x227e2
leaq 0x4148(%rip), %rsi      # 0x2691d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x186a5
leaq 0x3d44(%rip), %rsi      # 0x2652d
leaq 0x4136(%rip), %rdx      # 0x26926
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
testl %eax, %eax
je 0x227ce
movl 0x1f274(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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, 0x1e5f0(%rdi)
jne 0x22849
movl $0x0, 0x1f274(%rdi)
xorl %eax, %eax
retq
movw $0x7, 0x1e5f0(%rdi)
leaq 0x40c4(%rip), %rsi      # 0x2691d
jmp 0x13038
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x22d7d
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 0x11c92
testq %rax, %rax
je 0x22e61
movb $0x0, (%rax)
testq %rbx, %rbx
je 0x22e63
leaq 0x3190(%rip), %rdx      # 0x25f20
movq %rax, %rcx
cmpl $0x3, %r14d
jl 0x22de8
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 0x22db4
addq $0x4, %rcx
leal -0x3(%r14), %esi
addq $0x3, %rbx
cmpl $0x5, %r14d
movl %esi, %r14d
jg 0x22d99
jmp 0x22deb
movl %r14d, %esi
movb $0x0, (%rcx)
testl %esi, %esi
jle 0x22e63
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 0x22df9
cmpl $0x2, %esi
ja 0x22e22
leal -0x3(%rsi), %r8d
shlq $0x8, %rdi
incl %r8d
jne 0x22e19
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 0x22e28
cmpl $0x2, %esi
jg 0x22e5b
movl $0x3, %edx
movl %edx, %edi
movb $0x3d, (%rcx,%rdi)
decl %edx
cmpl %esi, %edx
jg 0x22e4f
movb $0x0, 0x4(%rcx)
jmp 0x22e63
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x2315e
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x2315e
movq %rcx, %r15
movq %rdx, %rax
testq %rdx, %rdx
jne 0x230df
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
shrq %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x11c92
testq %rax, %rax
je 0x2318b
movq %rax, %rcx
testq %r15, %r15
je 0x23153
xorl %edx, %edx
movq %rax, %rcx
movb (%r14,%rdx,2), %dil
testb %dil, %dil
je 0x2314d
movb 0x1(%r14,%rdx,2), %sil
testb %sil, %sil
je 0x23153
movl %edi, %r8d
andb $0x7, %r8b
addb $0x9, %r8b
cmpb $0x41, %dil
movzbl %dil, %edi
movzbl %r8b, %r8d
cmovll %edi, %r8d
shlb $0x4, %r8b
movl %esi, %edi
andb $0x7, %dil
addb $0x9, %dil
leal -0x30(%rsi), %r9d
cmpb $0x41, %sil
movzbl %r9b, %esi
movzbl %dil, %edi
cmovll %esi, %edi
addb %r8b, %dil
incq %rcx
movb %dil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r15
jne 0x230ec
addq %rax, %rdx
movq %rdx, %rcx
testq %rbx, %rbx
je 0x2317f
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x2317f
testq %rbx, %rbx
je 0x23169
movl $0x0, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x1f274(%r12)
leaq 0x2e46(%rip), %rcx      # 0x25fc1
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x2317f
// File: /workspace/github_c_makefile_star2_O3/hkshenSmart[P]ONVIF-discovery_cs/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 0x1c198(%rdi), %rbx
testq %rax, %rax
leaq 0x26fa(%rip), %rcx      # 0x25fc1
cmovneq %rax, %rcx
cmpb $0x0, 0x1c998(%rdi)
je 0x238f1
movq %rdi, %r8
addq $0x1c998, %r8           # imm = 0x1C998
leaq 0x400d(%rip), %rsi      # 0x278f2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3300
jmp 0x23902
leaq 0x4030(%rip), %rsi      # 0x27928
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3300
movq %rbx, %rax
popq %rbx
retq