LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x12ff7
testl %eax, %eax
jne 0x1edbd
cmpb $0x0, 0x1d598(%r14)
je 0x1ed0f
movq %r14, %rdi
movq %r13, %rsi
callq 0x1edd4
testl %eax, %eax
jne 0x1edba
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%r14)
je 0x1ed9b
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%r14)
je 0x1edbd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1edba
jmp 0x1edbd
testq %r15, %r15
je 0x1edcf
movq %r14, %rdi
callq 0x1df48
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1ebc9
testl %eax, %eax
je 0x1ed7f
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 0x1ed7f
// File: /workspace/github_c_makefile_star2_O1/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 0x1f036
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm0, %xmm1
subsd %xmm0, %xmm1
jbe 0x1eff2
ucomisd %xmm1, %xmm1
jnp 0x1eff2
leaq 0x766d(%rip), %rbx      # 0x2665d
jmp 0x1f031
ucomisd %xmm0, %xmm2
jbe 0x1f007
ucomisd %xmm1, %xmm1
jnp 0x1f007
leaq 0x7652(%rip), %rbx      # 0x26657
jmp 0x1f031
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 0x1f031
movb $0x2e, (%rax)
movq %rbx, %rax
popq %rbx
retq
leaq 0x7616(%rip), %rbx      # 0x26653
jmp 0x1f031
// File: /workspace/github_c_makefile_star2_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x1f092
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x1efc7
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x1f0a5
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x1f17c
movq %rsi, %r15
cmpb $0x0, (%rsi)
je 0x1f184
movq %rdx, %r14
leaq 0x7578(%rip), %rsi      # 0x2665d
movq %r15, %rdi
callq 0x10d91
testl %eax, %eax
je 0x1f16f
leaq 0x7564(%rip), %rsi      # 0x2665c
movq %r15, %rdi
callq 0x10d91
testl %eax, %eax
je 0x1f16f
leaq 0x754c(%rip), %rsi      # 0x26657
movq %r15, %rdi
callq 0x10d91
testl %eax, %eax
je 0x1f19f
leaq 0x7531(%rip), %rsi      # 0x26653
movq %r15, %rdi
callq 0x10d91
testl %eax, %eax
je 0x1f1ab
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30a0
movsd %xmm0, (%r14)
movq (%r12), %rax
cmpb $0x0, (%rax)
je 0x1f17c
leaq 0x7513(%rip), %rsi      # 0x26664
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3250
cmpl $0x1, %eax
je 0x1f17c
movl $0x4, 0x1f274(%rbx)
jmp 0x1f17c
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rax, (%r14)
movl 0x1f274(%rbx), %eax
jmp 0x1f193
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 0x1f179
movq $-0x1, (%r14)
jmp 0x1f17c
// File: /workspace/github_c_makefile_star2_O1/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 0x12ff7
testl %eax, %eax
jne 0x1f2b0
cmpb $0x0, 0x1d598(%r14)
je 0x1f202
movq %r14, %rdi
movq %r13, %rsi
callq 0x1edd4
testl %eax, %eax
jne 0x1f2ad
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%r14)
je 0x1f28e
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%r14)
je 0x1f2b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1f2ad
jmp 0x1f2b0
testq %r15, %r15
je 0x1f2c2
movq %r14, %rdi
callq 0x1df48
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1f0bb
testl %eax, %eax
je 0x1f272
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 0x1f272
// File: /workspace/github_c_makefile_star2_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x1f36a
movzbl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x7336(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x1f37d
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x12ff7
testl %eax, %eax
jne 0x1f549
cmpb $0x0, 0x1d598(%rbx)
je 0x1f49d
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1432a
testl %eax, %eax
je 0x1f49d
leaq 0x7214(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f49d
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1f546
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1f546
decl 0xc168(%rbx)
jmp 0x1f546
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1f527
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1f549
movq %rbx, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1f546
jmp 0x1f549
testq %r15, %r15
je 0x1f55b
movq %rbx, %rdi
callq 0x1df48
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1f393
testl %eax, %eax
je 0x1f50c
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 0x1f50c
// File: /workspace/github_c_makefile_star2_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x1f5e2
movzwl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x70be(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x1f5f5
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x12ff7
testl %eax, %eax
jne 0x1f7d8
cmpb $0x0, 0x1d598(%rbx)
je 0x1f72c
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1432a
testl %eax, %eax
je 0x1f72c
leaq 0x6fa9(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f72c
leaq 0x6f85(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f72c
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1f7d5
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1f7d5
decl 0xc168(%rbx)
jmp 0x1f7d5
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1f7b6
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1f7d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1f7d5
jmp 0x1f7d8
testq %r15, %r15
je 0x1f7ea
movq %rbx, %rdi
callq 0x1df48
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1f60b
testl %eax, %eax
je 0x1f79b
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 0x1f79b
// File: /workspace/github_c_makefile_star2_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x1f870
movl (%r15), %edx
leaq 0x1c598(%r14), %r15
leaq 0x6e30(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x1f883
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x1f8ff
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 0x1f8ea
testb $0x10, 0x5(%rbx)
jne 0x1f8f5
cmpb $0x0, (%rax)
jne 0x1f8f5
cmpl $0x22, (%r14)
jne 0x1f8ff
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_O1/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 0x12ff7
testl %eax, %eax
jne 0x1fa92
cmpb $0x0, 0x1d598(%rbx)
je 0x1f9e6
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1432a
testl %eax, %eax
je 0x1f9e6
leaq 0x5be2(%rip), %rdx      # 0x25553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f9e6
leaq 0x6cef(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f9e6
leaq 0x6ccb(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1f9e6
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1fa8f
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1fa8f
decl 0xc168(%rbx)
jmp 0x1fa8f
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1fa70
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1fa92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1fa8f
jmp 0x1fa92
testq %r15, %r15
je 0x1faa4
movq %rbx, %rdi
callq 0x1df48
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1f899
testl %eax, %eax
je 0x1fa55
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 0x1fa55
// File: /workspace/github_c_makefile_star2_O1/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 0x1fb99
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 0x1fb84
testb $0x10, 0x5(%rbx)
jne 0x1fb8f
cmpb $0x0, (%rax)
jne 0x1fb8f
cmpl $0x22, (%r14)
jne 0x1fb99
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_O1/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 0x12ff7
testl %eax, %eax
jne 0x1fd2c
cmpb $0x0, 0x1d598(%rbx)
je 0x1fc80
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1432a
testl %eax, %eax
je 0x1fc80
leaq 0x5948(%rip), %rdx      # 0x25553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1fc80
leaq 0x6a55(%rip), %rdx      # 0x26676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1fc80
leaq 0x6a31(%rip), %rdx      # 0x26668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1432a
testl %eax, %eax
je 0x1fc80
movl $0x4, 0x1f274(%rbx)
cmpw $0x0, 0x1e5f6(%rbx)
jne 0x1fd29
movw $0x1, 0x1e5f6(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x1fd29
decl 0xc168(%rbx)
jmp 0x1fd29
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 0x19303
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1fd0a
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 0x191b1
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1fd2c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
jne 0x1fd29
jmp 0x1fd2c
testq %r15, %r15
je 0x1fd3e
movq %rbx, %rdi
callq 0x1df48
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1fb33
testl %eax, %eax
je 0x1fcef
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 0x1fcef
// File: /workspace/github_c_makefile_star2_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x1fdc5
movq (%r15), %rdx
leaq 0x1c598(%r14), %r15
leaq 0x68db(%rip), %rsi      # 0x26685
movq %r15, %rdi
xorl %eax, %eax
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x1fdd8
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x20941
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 0x20941
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_O1/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 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x209fd
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2094c
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1bf80
testl %eax, %eax
je 0x20a10
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 0x18a90
// File: /workspace/github_c_makefile_star2_O1/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 0x21465
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 0x11dba
testq %rax, %rax
je 0x21465
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 0x21467
xorl %ebp, %ebp
movq %rbp, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x21856
movq %rsi, %r15
movq %rdi, %rbx
incq %rsi
callq 0x11dba
testq %rax, %rax
je 0x2185b
movq %rax, %r14
xorl %r12d, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0xc150(%rbx), %rax
cmpq 0xc158(%rbx), %rax
jb 0x21800
movq %rbx, %rdi
callq 0x10a3c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x2181a
movq 0xc150(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc150(%rbx)
movzbl 0xc198(%rbx,%rax), %ecx
cmpl $-0x1, %ecx
je 0x21860
movb %cl, (%r14,%r12)
incq %r12
cmpq %r12, %r15
jne 0x217df
movb $0x0, (%r14,%r12)
negl %r15d
andl $0x3, %r15d
je 0x21852
incq %r15
movq %rbx, %rdi
callq 0x10caf
cmpl $-0x1, %eax
je 0x21860
decq %r15
cmpq $0x2, %r15
jge 0x2183c
xorl %ebp, %ebp
jmp 0x21863
xorl %r14d, %r14d
jmp 0x21869
movl $0x14, %ebp
xorl %r14d, %r14d
movl %ebp, 0x1f274(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13324
movq %rax, 0x1f2e8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13324
movq %rax, 0x1f2f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ace5
movq %rbx, %rdi
callq 0x223a9
testl %eax, %eax
je 0x22370
cmpl $0x3e7, 0x1f274(%rbx)   # imm = 0x3E7
jg 0x2239c
movq %rbx, %rdi
popq %rbx
jmp 0x229a4
movq %rbx, %rdi
callq 0x22ba9
testl %eax, %eax
jne 0x22394
movq %rbx, %rdi
callq 0x22d11
testl %eax, %eax
jne 0x22394
movq %rbx, %rdi
callq 0x22d59
testl %eax, %eax
je 0x223a5
movl 0x1f274(%rbx), %eax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1495d
xorl %eax, %eax
jmp 0x2239a
// File: /workspace/github_c_makefile_star2_O1/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
je 0x22d31
cmpl $0x3, 0x1f274(%rbx)
jne 0x22d31
movl $0x0, 0x1f274(%rbx)
cmpl $0x0, 0x1f274(%rbx)
jne 0x22d51
movq 0xbfe0(%rbx), %rax
testq %rax, %rax
je 0x22d51
movq %rbx, %rdi
callq *%rax
movl %eax, 0x1f274(%rbx)
movl 0x1f274(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bad(%rip), %rsi      # 0x2691d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12ff7
testl %eax, %eax
je 0x22d88
movl 0x1f274(%r14), %ebx
jmp 0x22d9d
cmpw $0x0, 0xc166(%r14)
jne 0x22d9d
movw $0x5, 0x1e5f0(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3a0e(%rip), %rsi      # 0x2690b
callq 0x18a90
testl %eax, %eax
je 0x22f11
movl 0x1f274(%rbx), %eax
jmp 0x23010
movl $0x288, %eax            # imm = 0x288
andl 0x4(%rbx), %eax
cmpl $0x88, %eax
jne 0x22fd5
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 0x22f77
movq 0x18(%rax), %rcx
testq %rcx, %rcx
jne 0x22f70
movq 0x8(%rax), %rcx
movq %rcx, 0x1f2c0(%rbx)
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
movq 0x1f2c0(%rbx), %rdi
testq %rdi, %rdi
je 0x22fc9
callq 0x3110
addq $0x3, %rax
andq $-0x4, %rax
jmp 0x22fcb
xorl %eax, %eax
addq %rax, %r14
addq %r14, 0xc170(%rbx)
movl $0x280, %eax            # imm = 0x280
andl 0x4(%rbx), %eax
cmpl $0x80, %eax
jne 0x23005
xorl %edx, %edx
subl 0x1f290(%rbx), %edx
andl $0x3, %edx
leaq 0x2fcb(%rip), %rsi      # 0x25fc1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x102a8
movw $0x8, 0x1e5f0(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23041
xorl %r14d, %r14d
jmp 0x23051
movq 0xc178(%rbx), %r14
testq %r14, %r14
je 0x2311f
movq $0x0, 0xc190(%rbx)
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11ccc
movl $0x1, %r13d
testl %eax, %eax
jne 0x230ef
movq 0xc188(%rbx), %rcx
movq 0xc190(%rbx), %rax
movq 0xc180(%rbx), %r15
addq %rax, %r15
movq %rcx, %rbp
movq %rcx, 0xc190(%rbx)
subq %rax, %rbp
jne 0x230a1
xorl %r13d, %r13d
jmp 0x230ef
addq %r12, %rcx
subq %rax, %rcx
movq %rcx, (%rsp)
incq %r12
movl $0x7, %r13d
testq %r14, %r14
je 0x230c2
cmpq %r14, %r12
jbe 0x230c2
xorl %ecx, %ecx
jmp 0x230dc
movq %rbx, %rdi
callq 0x10caf
xorl %ecx, %ecx
cmpl $-0x1, %eax
je 0x230dc
movb %al, (%r15)
incq %r15
movb $0x1, %cl
xorl %r13d, %r13d
testb %cl, %cl
je 0x230ef
incq %r12
decq %rbp
jne 0x230ae
xorl %r13d, %r13d
movq (%rsp), %r12
testl %r13d, %r13d
je 0x2305f
cmpl $0x7, %r13d
jne 0x2311f
movb $0x0, (%r15)
movq 0xc180(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13324
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23162
movw $0x1, 0x1e5e8(%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x2317c
leaq 0x37ae(%rip), %rsi      # 0x2691d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x18a13
leaq 0x33aa(%rip), %rsi      # 0x2652d
leaq 0x379c(%rip), %rdx      # 0x26926
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b77e
testl %eax, %eax
je 0x23168
movl 0x1f274(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x231e3
movl $0x0, 0x1f274(%rdi)
xorl %eax, %eax
retq
movw $0x7, 0x1e5f0(%rdi)
leaq 0x372a(%rip), %rsi      # 0x2691d
jmp 0x131c3
// File: /workspace/github_c_makefile_star2_O1/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 0x23725
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 0x11dba
testq %rax, %rax
je 0x23795
movb $0x0, (%rax)
testq %rbx, %rbx
je 0x23810
leaq 0x27e3(%rip), %rdx      # 0x25f20
movq %rax, %rcx
cmpl $0x3, %r14d
jl 0x23799
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 0x23761
addq $0x4, %rcx
leal -0x3(%r14), %esi
addq $0x3, %rbx
cmpl $0x5, %r14d
movl %esi, %r14d
jg 0x23746
jmp 0x2379c
xorl %eax, %eax
jmp 0x23810
movl %r14d, %esi
movb $0x0, (%rcx)
testl %esi, %esi
jle 0x23810
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 0x237aa
cmpl $0x2, %esi
ja 0x237d3
leal -0x3(%rsi), %r8d
shlq $0x8, %rdi
incl %r8d
jne 0x237ca
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 0x237d9
cmpl $0x2, %esi
jg 0x2380c
movl $0x3, %edx
movl %edx, %edi
movb $0x3d, (%rcx,%rdi)
decl %edx
cmpl %esi, %edx
jg 0x23800
movb $0x0, 0x4(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23b1c
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x23b1c
movq %rcx, %r15
movq %rdx, %rax
testq %rdx, %rdx
jne 0x23a9a
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
shrq %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x11dba
testq %rax, %rax
je 0x23b49
movq %rax, %rcx
testq %r15, %r15
je 0x23b11
movb (%r14), %sil
testb %sil, %sil
je 0x23b08
movb 0x1(%r14), %dl
addq $0x2, %r14
testb %dl, %dl
je 0x23b0b
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 0x23b0d
incq %r14
xorl %edx, %edx
testb %dl, %dl
jne 0x23aa6
testq %rbx, %rbx
je 0x23b3d
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x23b3d
testq %rbx, %rbx
je 0x23b27
movl $0x0, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x1f274(%r12)
leaq 0x2488(%rip), %rcx      # 0x25fc1
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x23b3d
// File: /workspace/github_c_makefile_star2_O1/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 0x1d33(%rip), %rcx      # 0x25fc1
cmovneq %rax, %rcx
cmpb $0x0, 0x1c998(%rdi)
je 0x242b8
movq %rdi, %r8
addq $0x1c998, %r8           # imm = 0x1C998
leaq 0x3646(%rip), %rsi      # 0x278f2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3300
jmp 0x242c9
leaq 0x3669(%rip), %rsi      # 0x27928
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3300
movq %rbx, %rax
popq %rbx
retq