LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x11fde
testl %eax, %eax
jne 0x1ca75
cmpb $0x0, 0x1d598(%r14)
je 0x1c9d2
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c5d0
testl %eax, %eax
jne 0x1ca72
leaq 0x1cd98(%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x8
popq %r8
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x17600
movq %rax, %r15
cmpb $0x0, 0x1d198(%r14)
je 0x1ca53
leaq 0x1d198(%r14), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x8, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x174b8
movq %rax, %r15
cmpw $0x0, 0xc166(%r14)
je 0x1ca75
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12190
testl %eax, %eax
jne 0x1ca72
jmp 0x1ca75
testq %r15, %r15
je 0x1ca87
movq %r14, %rdi
callq 0x1b8bb
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1c890
testl %eax, %eax
je 0x1ca37
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 0x1ca37
// File: /workspace/github_c_makefile_star2_O2/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 0x169d2
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x16e14
testl %eax, %eax
jne 0x1cb06
movzbl (%r15), %esi
movq %r14, %rdi
callq 0x1ca93
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x19d82
testl %eax, %eax
je 0x1cb19
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 0x16e91
// File: /workspace/github_c_makefile_star2_O2/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 0x11fde
testl %eax, %eax
jne 0x1ccb5
cmpb $0x0, 0x1d598(%rbx)
je 0x1cc14
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x13169
testl %eax, %eax
je 0x1cc14
leaq 0x6a7a(%rip), %rdx      # 0x23668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1cc14
movl $0x4, 0x1f274(%rbx)
movq %rbx, %rdi
callq 0x1a4da
jmp 0x1ccb2
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x17600
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1cc93
leaq 0x1d198(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x1, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x174b8
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1ccb5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
jne 0x1ccb2
jmp 0x1ccb5
testq %r15, %r15
je 0x1ccc7
movq %rbx, %rdi
callq 0x1b8bb
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1cb2f
testl %eax, %eax
je 0x1cc78
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 0x1cc78
// File: /workspace/github_c_makefile_star2_O2/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 0x169d2
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x16e14
testl %eax, %eax
jne 0x1cd25
movzwl (%r15), %esi
movq %r14, %rdi
callq 0x1ca93
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x19d82
testl %eax, %eax
je 0x1cd38
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 0x16e91
// File: /workspace/github_c_makefile_star2_O2/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 0x11fde
testl %eax, %eax
jne 0x1ceeb
cmpb $0x0, 0x1d598(%rbx)
je 0x1ce4a
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x13169
testl %eax, %eax
je 0x1ce4a
leaq 0x6868(%rip), %rdx      # 0x23676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1ce4a
leaq 0x6844(%rip), %rdx      # 0x23668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1ce4a
movl $0x4, 0x1f274(%rbx)
movq %rbx, %rdi
callq 0x1a4da
jmp 0x1cee8
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x2
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x17600
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1cec9
leaq 0x1d198(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x2, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x174b8
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1ceeb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
jne 0x1cee8
jmp 0x1ceeb
testq %r15, %r15
je 0x1cefd
movq %rbx, %rdi
callq 0x1b8bb
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1cd4e
testl %eax, %eax
je 0x1ceae
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 0x1ceae
// File: /workspace/github_c_makefile_star2_O2/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 0x1cfe4
movq %rdx, %r12
movq %rsi, %r15
callq 0x3050
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
movl %eax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x1cfcf
testb $0x10, 0x5(%rbx)
jne 0x1cfda
cmpb $0x0, (%rax)
jne 0x1cfda
cmpl $0x22, (%r14)
jne 0x1cfe4
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_O2/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 0x11fde
testl %eax, %eax
jne 0x1d145
cmpb $0x0, 0x1d598(%rbx)
je 0x1d0a4
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x13169
testl %eax, %eax
je 0x1d0a4
leaq 0x5501(%rip), %rdx      # 0x22553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d0a4
leaq 0x660e(%rip), %rdx      # 0x23676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d0a4
leaq 0x65ea(%rip), %rdx      # 0x23668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d0a4
movl $0x4, 0x1f274(%rbx)
movq %rbx, %rdi
callq 0x1a4da
jmp 0x1d142
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x4
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x17600
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1d123
leaq 0x1d198(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x4, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x174b8
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1d145
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
jne 0x1d142
jmp 0x1d145
testq %r15, %r15
je 0x1d157
movq %rbx, %rdi
callq 0x1b8bb
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1cf83
testl %eax, %eax
je 0x1d108
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 0x1d108
// File: /workspace/github_c_makefile_star2_O2/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 0x1d237
movq %rdx, %r12
movq %rsi, %r15
callq 0x3050
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
movq %rax, (%r12)
movq (%r13), %rax
cmpq %r15, %rax
jne 0x1d222
testb $0x10, 0x5(%rbx)
jne 0x1d22d
cmpb $0x0, (%rax)
jne 0x1d22d
cmpl $0x22, (%r14)
jne 0x1d237
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_O2/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 0x11fde
testl %eax, %eax
jne 0x1d398
cmpb $0x0, 0x1d598(%rbx)
je 0x1d2f7
leaq 0x1d598(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x13169
testl %eax, %eax
je 0x1d2f7
leaq 0x52ae(%rip), %rdx      # 0x22553
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d2f7
leaq 0x63bb(%rip), %rdx      # 0x23676
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d2f7
leaq 0x6397(%rip), %rdx      # 0x23668
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13169
testl %eax, %eax
je 0x1d2f7
movl $0x4, 0x1f274(%rbx)
movq %rbx, %rdi
callq 0x1a4da
jmp 0x1d395
leaq 0x1cd98(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x8
popq %r8
movq %rbx, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x17600
movq %rax, %r15
cmpb $0x0, 0x1d198(%rbx)
je 0x1d376
leaq 0x1d198(%rbx), %rsi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x8, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x174b8
movq %rax, %r15
cmpw $0x0, 0xc166(%rbx)
je 0x1d398
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12190
testl %eax, %eax
jne 0x1d395
jmp 0x1d398
testq %r15, %r15
je 0x1d3aa
movq %rbx, %rdi
callq 0x1b8bb
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1d1d6
testl %eax, %eax
je 0x1d35b
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 0x1d35b
// File: /workspace/github_c_makefile_star2_O2/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 0x169d2
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x16e14
testl %eax, %eax
jne 0x1d421
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1d3af
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x19d82
testl %eax, %eax
je 0x1d434
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 0x16e91
// File: /workspace/github_c_makefile_star2_O2/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 0x3290
movq %rax, 0x8(%rsp)
pushq $-0x1
popq %rbx
cmpq $-0x1, %rax
je 0x1de8b
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x3170
andl $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x3290
cmpq $-0x1, %rax
je 0x1de8b
movq 0x8(%rsp), %rbx
addq %rbx, %rbx
subq %rax, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e87d
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 0x10ebe
testq %rax, %rax
je 0x1e87d
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 0x1e87f
xorl %ebp, %ebp
movq %rbp, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x1ebf6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
incq %rsi
callq 0x10ebe
testq %rax, %rax
je 0x1ec22
movq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x1ebf9
movq 0xc150(%rbx), %rax
cmpq 0xc158(%rbx), %rax
jb 0x1ebdb
movq %rbx, %rdi
callq 0xfce2
testl %eax, %eax
jne 0x1ec2e
movq 0xc150(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc150(%rbx)
movb 0xc198(%rbx,%rax), %al
movb %al, (%r15,%r12)
incq %r12
jmp 0x1ebb3
xorl %eax, %eax
retq
movb $0x0, (%r15,%r12)
negl %r14d
andl $0x3, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10895
movl %eax, %ecx
movl %eax, 0x1f274(%rbx)
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %r15, %rax
jmp 0x1ec37
movl $0x14, 0x1f274(%rbx)
jmp 0x1ec35
orl $-0x1, 0x1f274(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18c91
movq %rbx, %rdi
callq 0x1f634
testl %eax, %eax
je 0x1f5fb
cmpl $0x3e7, 0x1f274(%rbx)   # imm = 0x3E7
jg 0x1f627
movq %rbx, %rdi
popq %rbx
jmp 0x1fc68
movq %rbx, %rdi
callq 0x1fe02
testl %eax, %eax
jne 0x1f61f
movq %rbx, %rdi
callq 0x1ff6b
testl %eax, %eax
jne 0x1f61f
movq %rbx, %rdi
callq 0x1ffb6
testl %eax, %eax
je 0x1f630
movl 0x1f274(%rbx), %eax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x13665
xorl %eax, %eax
jmp 0x1f625
// File: /workspace/github_c_makefile_star2_O2/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 0x38e4
testl %eax, %eax
setne %cl
movl 0x1f274(%rbx), %eax
cmpl $0x3, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1ff95
andl $0x0, 0x1f274(%rbx)
jmp 0x1ff99
testl %eax, %eax
jne 0x1ffb4
movq 0xbfe0(%rbx), %rax
testq %rax, %rax
je 0x1ffb2
movq %rbx, %rdi
callq *%rax
movl %eax, 0x1f274(%rbx)
jmp 0x1ffb4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3950(%rip), %rsi      # 0x2391d
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x11fde
testl %eax, %eax
je 0x1ffe5
movl 0x1f274(%r14), %ebx
jmp 0x1fffa
cmpw $0x0, 0xc166(%r14)
jne 0x1fffa
movw $0x5, 0x1e5f0(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37ba(%rip), %rsi      # 0x2390b
callq 0x16e91
testl %eax, %eax
je 0x20165
movl 0x1f274(%rbx), %eax
jmp 0x20268
movl 0x4(%rbx), %eax
movl %eax, %ecx
andl $0x288, %ecx            # imm = 0x288
cmpl $0x88, %ecx
jne 0x20232
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 0x3310
movq %r14, 0x1f2b8(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x201d1
movq 0x18(%rax), %r15
testq %r15, %r15
jne 0x201c8
movq 0x8(%rax), %r15
movq %r15, 0x1f2c0(%rbx)
jmp 0x201d8
movq 0x1f2c0(%rbx), %r15
andq $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 0x20223
movq %r15, %rdi
callq 0x3110
addq $0x3, %rax
andq $-0x4, %rax
jmp 0x20225
xorl %eax, %eax
addq %rax, %r14
addq %r14, 0xc170(%rbx)
movl 0x4(%rbx), %eax
andl $0x280, %eax            # imm = 0x280
cmpl $0x80, %eax
jne 0x2025d
xorl %edx, %edx
subl 0x1f290(%rbx), %edx
andl $0x3, %edx
leaq 0x2d71(%rip), %rsi      # 0x22fc1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf63c
movw $0x8, 0x1e5f0(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20297
xorl %r14d, %r14d
jmp 0x202a7
movq 0xc178(%rbx), %r14
testq %r14, %r14
je 0x2034d
andq $0x0, 0xc190(%rbx)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10df6
testl %eax, %eax
jne 0x2034d
movq 0xc188(%rbx), %rcx
movq 0xc190(%rbx), %rax
movq 0xc180(%rbx), %r13
addq %rax, %r13
movq %rcx, %rbp
subq %rax, %rbp
movq %rcx, 0xc190(%rbx)
addq %r15, %rcx
subq %rax, %rcx
movq %rcx, (%rsp)
incq %r15
xorl %r12d, %r12d
cmpq %r12, %rbp
je 0x20325
testq %r14, %r14
je 0x2030e
leaq (%r15,%r12), %rax
cmpq %r14, %rax
ja 0x2032b
movq %rbx, %rdi
callq 0xff4d
cmpl $-0x1, %eax
je 0x2032b
movb %al, (%r13,%r12)
incq %r12
jmp 0x202fb
movq (%rsp), %r15
jmp 0x202b2
movb $0x0, (%r12,%r13)
movq 0xc180(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x122d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20390
movw $0x1, 0x1e5e8(%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x203aa
leaq 0x3580(%rip), %rsi      # 0x2391d
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x16e14
leaq 0x317c(%rip), %rsi      # 0x2352d
leaq 0x356e(%rip), %rdx      # 0x23926
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x19643
testl %eax, %eax
je 0x20396
movl 0x1f274(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2040c
andl $0x0, 0x1f274(%rdi)
xorl %eax, %eax
retq
movw $0x7, 0x1e5f0(%rdi)
leaq 0x3501(%rip), %rsi      # 0x2391d
jmp 0x12190
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdx, %rax
movq %rsi, %r14
testq %rdx, %rdx
jne 0x208b5
leal 0x2(%rbx), %eax
pushq $0x3
popq %rcx
cltd
idivl %ecx
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
callq 0x10ebe
testq %rax, %rax
je 0x2098b
movb $0x0, (%rax)
testq %r14, %r14
je 0x2098d
pushq $0x3
popq %rcx
pushq $0x4
popq %rdi
leaq 0x2652(%rip), %rsi      # 0x22f20
movq %rax, %rdx
cmpl $0x3, %ebx
jl 0x20924
movzbl (%r14), %r8d
movzbl 0x1(%r14), %r9d
shll $0x10, %r8d
shll $0x8, %r9d
orl %r8d, %r9d
movzbl 0x2(%r14), %r8d
orq %r9, %r8
movq %rdi, %r10
movq %rdi, %r9
subq $0x1, %r9
jb 0x20917
movl %r8d, %r11d
andl $0x3f, %r11d
movb (%r11,%rsi), %r11b
movb %r11b, -0x1(%rdx,%r10)
shrq $0x6, %r8
movq %r9, %r10
jmp 0x208f8
addq $0x4, %rdx
addl $-0x3, %ebx
addq $0x3, %r14
jmp 0x208d1
movb $0x0, (%rdx)
testl %ebx, %ebx
jle 0x2098d
xorl %r8d, %r8d
xorl %edi, %edi
cmpl %ebx, %r8d
jge 0x2094d
shlq $0x8, %rdi
movzbl (%r14,%r8), %r9d
orq %r9, %rdi
incq %r8
jmp 0x20930
shlq $0x8, %rdi
incl %r8d
cmpl $0x3, %r8d
jb 0x20946
pushq $0x4
popq %r9
movq %r9, %r8
subq $0x1, %r8
jb 0x20981
movl %edi, %r10d
andl $0x3f, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrq $0x6, %rdi
movq %r8, %r9
jmp 0x2095a
movl %ecx, %esi
movb $0x3d, (%rdx,%rsi)
decl %ecx
cmpl %ebx, %ecx
jg 0x20979
movb $0x0, 0x4(%rdx)
jmp 0x2098d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20c69
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x20c69
movq %rcx, %r15
movq %rdx, %rax
testq %rdx, %rdx
jne 0x20c0b
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
shrq %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x10ebe
testq %rax, %rax
je 0x20c92
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x20c89
movb (%r14,%rcx,2), %sil
testb %sil, %sil
je 0x20c89
movb 0x1(%r14,%rcx,2), %dl
testb %dl, %dl
je 0x20c89
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, (%rax,%rcx)
incq %rcx
jmp 0x20c0d
testq %rbx, %rbx
je 0x20c71
andl $0x0, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x1f274(%r12)
leaq 0x233e(%rip), %rcx      # 0x22fc1
cmoveq %rcx, %rax
jmp 0x20c94
testq %rbx, %rbx
je 0x20c94
movl %ecx, (%rbx)
jmp 0x20c94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c0a(%rip), %rcx      # 0x22fc1
cmovneq %rax, %rcx
cmpb $0x0, 0x1c998(%rdi)
je 0x213e1
movq %rdi, %r8
addq $0x1c998, %r8           # imm = 0x1C998
leaq 0x351d(%rip), %rsi      # 0x248f2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3310
jmp 0x213f2
leaq 0x3540(%rip), %rsi      # 0x24928
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3310
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_strerror
static const char*
soap_strerror(struct soap *soap)
{ register int err = soap->errnum;
  if (err)
  {
#ifndef WIN32
# ifdef HAVE_STRERROR_R
    strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf));
# else
    return strerror(err);
# endif
#else
#ifndef UNDER_CE
    DWORD len;
    *soap->msgbuf = '\0';
    len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)soap->msgbuf, (DWORD)sizeof(soap->msgbuf), NULL);
#else
    DWORD i, len;
    *soap->msgbuf = '\0';
    len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
    for (i = 0; i <= len; i++)
    { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
        soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
      else
        soap->msgbuf[i] = '?';
    }
#endif
#endif
  }
  else
  { char *s = soap->msgbuf;
#ifndef WITH_LEAN
    int rt = soap->recv_timeout, st = soap->send_timeout;
    int ru = ' ', su = ' ';
#endif
    strcpy(s, "Operation interrupted or timed out");
#ifndef WITH_LEAN
    if (rt < 0)
    { rt = -rt;
      ru = 'u';
    }
    if (st < 0)
    { st = -st;
      su = 'u';
    }
    if (rt)
      sprintf(s + strlen(s), " (%d%cs receive delay)", rt, ru);
    if (st)
      sprintf(s + strlen(s), " (%d%cs send delay)", st, su);
#endif
  }
  return soap->msgbuf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
movl 0x1f27c(%rdi), %edi
leaq 0x1c198(%rax), %rbx
testl %edi, %edi
je 0x21428
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x30c0
jmp 0x214bd
movl 0x50(%rax), %ecx
movl 0x54(%rax), %r13d
movups 0x374e(%rip), %xmm0     # 0x24b84
movups %xmm0, 0x10(%rbx)
movups 0x3733(%rip), %xmm0     # 0x24b74
movups %xmm0, (%rbx)
movl %r13d, %ebp
negl %ebp
cmovsl %r13d, %ebp
movl $0x74756f, 0x1f(%rbx)   # imm = 0x74756F
testl %r13d, %r13d
pushq $0x75
popq %rax
pushq $0x20
popq %r15
movl %r15d, %r14d
cmovsl %eax, %r14d
testl %ecx, %ecx
je 0x21499
movl %ecx, %r12d
negl %r12d
cmovsl %ecx, %r12d
testl %ecx, %ecx
cmovsl %eax, %r15d
movq %rbx, %rdi
callq 0x3110
leaq (%rax,%rbx), %rdi
leaq 0x370b(%rip), %rsi      # 0x24b97
movl %r12d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x3310
testl %r13d, %r13d
je 0x214bd
movq %rbx, %rdi
callq 0x3110
leaq (%rax,%rbx), %rdi
leaq 0x36fd(%rip), %rsi      # 0x24bae
movl %ebp, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3310
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: http_error
static const char*
http_error(struct soap *soap, int status)
{ register const char *msg = SOAP_STR_EOS;
#ifndef WITH_LEAN
  msg = soap_code_str(h_http_error_codes, status);
  if (!msg)
    msg = SOAP_STR_EOS;
#endif
  return msg;
}

// Assembly:
pushq %rax
movl %edi, %esi
leaq 0x11697(%rip), %rdi     # 0x32b70
callq 0x1011d
testq %rax, %rax
leaq 0x1ad9(%rip), %rcx      # 0x22fc1
cmoveq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_send_empty_response
SOAP_FMAC2
soap_send_empty_response(struct soap *soap, int httpstatuscode)
{ register soap_mode m = soap->omode;
  soap->count = 0;
  if ((m & SOAP_IO) == SOAP_IO_CHUNK)
    soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
  if (!soap_response(soap, httpstatuscode) && !soap_end_send(soap))
    soap->error = SOAP_STOP; /* stops the server's response */
  soap->omode = m;
  return soap_closesock(soap);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %ebp
andq $0x0, 0xc170(%rdi)
movl %ebp, %eax
notl %eax
testb $0x3, %al
jne 0x2167f
movl %ebp, %eax
andl $-0x3, %eax
movl %eax, 0xc(%rbx)
movq %rbx, %rdi
callq 0x15e71
testl %eax, %eax
jne 0x216a1
movq %rbx, %rdi
callq 0x1773a
testl %eax, %eax
jne 0x216a1
movl $0x3e8, 0x1f274(%rbx)   # imm = 0x3E8
movl %ebp, 0xc(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13665
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_recv_empty_response
SOAP_FMAC2
soap_recv_empty_response(struct soap *soap)
{ if (!soap_begin_recv(soap))
    soap_end_recv(soap);
  else if (soap->error == SOAP_NO_DATA || soap->error == 202)
    soap->error = SOAP_OK;
  return soap_closesock(soap);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1f634
testl %eax, %eax
je 0x216da
movl 0x1f274(%rbx), %eax
cmpl $0xca, %eax
je 0x216d1
cmpl $0xe, %eax
jne 0x216e2
andl $0x0, 0x1f274(%rbx)
jmp 0x216e2
movq %rbx, %rdi
callq 0x17d11
movq %rbx, %rdi
popq %rbx
jmp 0x13665
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: soap_set_error
static int
soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
{ *soap_faultcode(soap) = faultcode;
  if (faultsubcodeQName)
    *soap_faultsubcode(soap) = faultsubcodeQName;
  *soap_faultstring(soap) = faultstring;
  if (faultdetailXML && *faultdetailXML)
  { register const char **s = soap_faultdetail(soap);
    if (s)
      *s = faultdetailXML;
  }
  return soap->error = soaperror;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
callq 0x3fd1
movq %rbp, (%rax)
testq %r13, %r13
je 0x21720
movq %r15, %rdi
callq 0x3ff4
movq %r13, (%rax)
movq %r15, %rdi
callq 0x404d
movq %r12, (%rax)
testq %r14, %r14
je 0x21746
cmpb $0x0, (%r14)
je 0x21746
movq %r15, %rdi
callq 0x4070
testq %rax, %rax
je 0x21746
movq %r14, (%rax)
movl %ebx, 0x1f274(%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hkshenSmart[P]ONVIF-discovery_cs/stdsoap2.c
// Function: http_send_header
static int
http_send_header(struct soap *soap, const char *s)
{ register const char *t;
  do
  { t = strchr(s, '\n'); /* disallow \n in HTTP headers */
    if (!t)
      t = s + strlen(s);
    if (soap_send_raw(soap, s, t - s))
      return soap->error;
    s = t + 1;
  } while (*t);
  return SOAP_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x3130
movq %rax, %r15
testq %rax, %rax
jne 0x21c3d
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
addq %r14, %r15
movq %r15, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf63c
testl %eax, %eax
jne 0x21c60
leaq 0x1(%r15), %r14
cmpb $0x0, (%r15)
jne 0x21c1d
xorl %eax, %eax
jmp 0x21c66
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: create_pid_file
void create_pid_file(const char *pidfile)
{
	FILE *fp = fopen(pidfile, "w");

	if (fp) {
		fprintf(fp, "%d\n", (int)getpid());
		fclose(fp);
	}
}

// Assembly:
pushq %rbx
leaq 0x9a99(%rip), %rsi      # 0xc06d
callq 0x23c0
testq %rax, %rax
je 0x2602
movq %rax, %rbx
callq 0x2100
leaq 0x9a82(%rip), %rsi      # 0xc06f
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x2260
movq %rbx, %rdi
popq %rbx
jmp 0x2120
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: daemonize
void daemonize(void)
{
	int fd;

	if (fork() != 0) {
		exit(0);
	}

	setsid();

	if ((fd = open("/dev/null", O_RDWR, 0)) != -1)
	{
		dup2(fd, STDIN_FILENO);
		dup2(fd, STDOUT_FILENO);
		dup2(fd, STDERR_FILENO);
		if (fd > STDERR_FILENO) {
			close(fd);
		}
	}
}

// Assembly:
pushq %rbx
callq 0x2490
testl %eax, %eax
jne 0x2659
callq 0x21e0
leaq 0x9a59(%rip), %rdi      # 0xc073
pushq $0x2
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x23a0
cmpl $-0x1, %eax
je 0x2657
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x2160
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x2160
pushq $0x2
popq %rsi
movl %ebx, %edi
callq 0x2160
cmpl $0x3, %ebx
jl 0x2657
movl %ebx, %edi
popq %rbx
jmp 0x21d0
popq %rbx
retq
xorl %edi, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: unblock_open_files_limit
void unblock_open_files_limit(void)
{
	rlim_t maxfiles = server->max_clients + 32;
	rlim_t oldlimit;
	struct rlimit limit;

	if (maxfiles < 1024) {
		maxfiles = 1024;
	}

	if (getrlimit(RLIMIT_NOFILE, &limit) == -1) {
		warning("Error getrlimit", strerror(errno));
		server->max_clients = 1024 - 32;
	} else {
		oldlimit = limit.rlim_cur;

		if (oldlimit < maxfiles) {
			limit.rlim_cur = maxfiles;
			limit.rlim_max = maxfiles;

			if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
				server->max_clients = oldlimit - 32;
			}
		}
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0xfc22(%rip), %rax      # 0x12290
movq 0x48(%rax), %rax
addq $0x20, %rax
cmpq $0x401, %rax            # imm = 0x401
movl $0x400, %r14d           # imm = 0x400
cmovaeq %rax, %r14
pushq $0x7
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x2470
cmpl $-0x1, %eax
je 0x26c1
movq 0x8(%rsp), %rbx
cmpq %r14, %rbx
jae 0x26ee
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %r14, 0x8(%rsi)
pushq $0x7
popq %rdi
callq 0x2330
cmpl $-0x1, %eax
jne 0x26ee
addq $-0x20, %rbx
jmp 0x26e3
callq 0x2050
movl (%rax), %edi
callq 0x2480
leaq 0x99a9(%rip), %rdi      # 0xc07d
movq %rax, %rsi
xorl %eax, %eax
callq 0x4548
movl $0x3e0, %ebx            # imm = 0x3E0
movq 0xfba6(%rip), %rax      # 0x12290
movq %rbx, 0x48(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: linux_overcommit_memory_value
int linux_overcommit_memory_value(void)
{
	FILE *fp;
	char buf[64];

	if ((fp = fopen("/proc/sys/vm/overcommit_memory", "r")) == NULL)
		return -1;

	if (fgets(buf, 64, fp) == NULL)
	{
		fclose(fp);
		return -1;
	}

	fclose(fp);

	return atoi(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x9987(%rip), %rdi      # 0xc08d
leaq 0xa155(%rip), %rsi      # 0xc862
callq 0x23c0
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x2745
movq %rax, %r14
movq %rsp, %rdi
pushq $0x40
popq %rsi
movq %rax, %rdx
callq 0x2210
movq %rax, %r15
movq %r14, %rdi
callq 0x2120
testq %r15, %r15
je 0x2745
movq %rsp, %rdi
callq 0x2420
movl %eax, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: setup_signals
void setup_signals(void)
{
	struct sigaction sig;

	signal(SIGHUP, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);

	sigemptyset(&sig.sa_mask);
	sig.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
	sig.sa_handler = sigterm_handler;

	sigaction(SIGTERM, &sig, NULL);
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
pushq $0x1
popq %rdi
pushq $0x1
popq %rbx
movq %rbx, %rsi
callq 0x2240
pushq $0xd
popq %rdi
movq %rbx, %rsi
callq 0x2240
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2270
movl $0xc8000000, 0x80(%rbx) # imm = 0xC8000000
leaq -0x61(%rip), %rax       # 0x276c
movq %rax, -0x8(%rbx)
pushq $0xf
popq %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x20a0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/yakushstanislav[P]EagleMQ/src/eagle.c
// Function: mstime
long long mstime(void)
{
	struct timeval tv;
	long long mst;

	gettimeofday(&tv, NULL);

	mst = tv.tv_sec * 1000;
	mst += tv.tv_usec / 1000;

	return mst;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21a0
imulq $0x3e8, (%rbx), %rcx    # imm = 0x3E8
movq 0x8(%rbx), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
addq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq