LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/cinemast[P]sudoku/sudoku.c
// Function: trim_string
static
const char * 
trim_string (const char *   buffer,
             size_t         buffsize,
             const char *   prefixes)
{
    const char * p = buffer;
    if (p && buffsize > 0) {
        if (prefixes != NULL &&
            strchr(prefixes,*p) != NULL) {
            ++p;
            --buffsize;
        }
        while (buffsize > 0 && ' ' == *p) {
            ++p;
            --buffsize;
        }
    }
    if (buffsize == 0) {
        p = NULL;
    }
    return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x86ac
testq %rdx, %rdx
je 0x8683
movsbl (%rbx), %esi
movq %rdx, %rdi
callq 0x2120
testq %rax, %rax
je 0x8683
incq %rbx
decq %r14
testq %r14, %r14
je 0x86a1
leaq (%rbx,%r14), %rax
cmpb $0x20, (%rbx)
jne 0x86a6
incq %rbx
decq %r14
jne 0x868c
xorl %r14d, %r14d
movq %rax, %rbx
jmp 0x86ac
xorl %r14d, %r14d
jmp 0x86ac
movl $0x1, %r14d
testq %r14, %r14
cmoveq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/eridanhq[P]miraclelib/init.c
// Function: main
int main(int argc, char *argv[])
{
	int memfd;
	void *mapped_base;
	int jesd_phase; // jesd phase readback value

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page

	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, SPI_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}

	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	jesd_phase = init_tx(mapped_base);
	printf("%d\n",jesd_phase);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */

	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xdbd(%rip), %rdi       # 0x2004
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x10f0
cmpl $-0x1, %eax
je 0x12c0
movl %eax, %ebx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x64000000, %r9d       # imm = 0x64000000
movl $0x3, %edx
movl $0x11, %ecx
movl %eax, %r8d
callq 0x1080
cmpq $-0x1, %rax
je 0x12c9
movq %rax, %r14
movq %rax, %rdi
callq 0x1afd
leaq 0xead(%rip), %rdi       # 0x2141
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
movl $0x400000, %esi         # imm = 0x400000
movq %r14, %rdi
callq 0x10e0
cmpl $-0x1, %eax
je 0x12d2
movl %ebx, %edi
callq 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd8e(%rip), %rdi       # 0x2055
jmp 0x12d9
leaq 0xd61(%rip), %rdi       # 0x2031
jmp 0x12d9
leaq 0xd34(%rip), %rdi       # 0x200d
callq 0x1060
xorl %edi, %edi
callq 0x1120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_SOAP_ENV__Header
SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__wsa__MessageID(soap, &a->wsa__MessageID);
	soap_serialize_PointerTo_wsa__RelatesTo(soap, &a->wsa__RelatesTo);
	soap_serialize_PointerTo_wsa__From(soap, &a->wsa__From);
	soap_serialize_PointerTo_wsa__ReplyTo(soap, &a->wsa__ReplyTo);
	soap_serialize_PointerTo_wsa__FaultTo(soap, &a->wsa__FaultTo);
	soap_serialize__wsa__To(soap, &a->wsa__To);
	soap_serialize__wsa__Action(soap, &a->wsa__Action);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl $0x4, %edx
callq 0x183b9
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xba61
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xba2c
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xb9f7
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xb9c2
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x183b9
movq 0x30(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x183b9
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_getheader
SOAP_FMAC4 soap_getheader(struct soap *soap)
{
	soap->part = SOAP_IN_HEADER;
	soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
	soap->part = SOAP_END_HEADER;
	return soap->header == NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movw $0x3, 0x1e5f0(%rdi)
leaq 0x21c03(%rip), %rsi     # 0x25520
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3942
movq %rax, 0xbf30(%rbx)
movw $0x4, 0x1e5f0(%rbx)
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_SOAP_ENV__Fault
SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__QName(soap, &a->faultcode);
	soap_serialize_string(soap, &a->faultstring);
	soap_serialize_string(soap, &a->faultactor);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
	soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
	soap_serialize_string(soap, &a->SOAP_ENV__Node);
	soap_serialize_string(soap, &a->SOAP_ENV__Role);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movl $0x4, %edx
callq 0x183b9
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xc380
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xc3bc
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xc3fb
movq 0x30(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
movq 0x38(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc380
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_faultstring
SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
		return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
	return (const char**)&soap->fault->faultstring;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3ddf
cmpw $0x2, 0x2(%rbx)
movq 0xbf38(%rbx), %rax
jne 0x40e4
movq 0x28(%rax), %rax
jmp 0x40e8
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_getindependent
SOAP_FMAC4 soap_getindependent(struct soap *soap)
{
	int t;
	if (soap->version == 1)
	{	for (;;)
		{	if (!soap_getelement(soap, &t))
				if (soap->error || soap_ignore_element(soap))
					break;
		}
	}
	if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
		soap->error = SOAP_OK;
	return soap->error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x2(%rdi)
jne 0x41a4
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41cc
testq %rax, %rax
jne 0x417f
cmpl $0x0, 0x1f274(%rbx)
jne 0x41a4
movq %rbx, %rdi
callq 0x5053
testl %eax, %eax
je 0x417f
movl 0x1f274(%rbx), %eax
cmpl $0x6, %eax
je 0x41b4
cmpl $-0x1, %eax
jne 0x41be
movl $0x0, 0x1f274(%rbx)
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_ignore_element
SOAP_FMAC4 soap_ignore_element(struct soap *soap)
{
	if (!soap_peek_element(soap))
	{	int t;
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
		if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
		{	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
			return soap->error = SOAP_TAG_MISMATCH;
		}
		if (!*soap->id || !soap_getelement(soap, &t))
		{	soap->peeked = 0;
			if (soap->fignore)
				soap->error = soap->fignore(soap, soap->tag);
			else
				soap->error = SOAP_OK;
			DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
			if (!soap->error && soap->body)
			{	soap->level++;
				while (!soap_ignore_element(soap))
					;
				if (soap->error == SOAP_NO_TAG)
					soap->error = soap_element_end_in(soap, NULL);
			}
		}
	}
	return soap->error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x122e8
testl %eax, %eax
je 0x5071
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x10, 0x5(%rbx)
je 0x5081
cmpw $0x3, 0x1e5f0(%rbx)
jne 0x50d8
leaq 0x1c998(%rbx), %r14
leaq 0x2072e(%rip), %rdx     # 0x257bd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1432a
testl %eax, %eax
je 0x50d8
cmpb $0x0, 0x1cd98(%rbx)
je 0x50b9
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x41cc
testq %rax, %rax
jne 0x5063
movw $0x0, 0x1e5f6(%rbx)
movq 0xc048(%rbx), %rax
testq %rax, %rax
je 0x50e9
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
jmp 0x50eb
movl $0x3, 0x1f274(%rbx)
movl $0x3, %eax
jmp 0x5069
xorl %eax, %eax
movl %eax, 0x1f274(%rbx)
testl %eax, %eax
jne 0x5063
cmpw $0x0, 0xc166(%rbx)
je 0x5063
incl 0xc168(%rbx)
movq %rbx, %rdi
callq 0x5053
testl %eax, %eax
je 0x510d
cmpl $0x6, 0x1f274(%rbx)
jne 0x5063
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131c3
movl %eax, 0x1f274(%rbx)
jmp 0x5063
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_in_PointerTounsignedInt
SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTounsignedInt(struct soap *soap, const char *tag, unsigned int **a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_unsignedInt(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedInt, sizeof(unsigned int), 0);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x12ff7
testl %eax, %eax
jne 0x8ca8
testq %rbx, %rbx
jne 0x8c20
movl $0x8, %esi
movq %r15, %rdi
callq 0x11dba
movq %rax, %rbx
testq %rax, %rax
je 0x8c79
movq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x8c3c
cmpb $0x23, 0x1d198(%r15)
jne 0x8c7e
leaq 0x1d198(%r15), %rsi
movl $0x4, %r8d
movq %r15, %rdi
movq %rbx, %rdx
movl $0x1b, %ecx
xorl %r9d, %r9d
callq 0x18fbf
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x8ca5
movq %r15, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
je 0x8ca5
xorl %r13d, %r13d
jmp 0x8ca8
movq %r15, %rdi
callq 0x1c757
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x1b, %r8d
callq 0x1f913
movq %rax, (%rbx)
testq %rax, %rax
je 0x8c79
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_in_PointerTo_QName
SOAP_FMAC3 char *** SOAP_FMAC4 soap_in_PointerTo_QName(struct soap *soap, const char *tag, char ***a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (char ***)soap_malloc(soap, sizeof(char **))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in__QName(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (char ***)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__QName, sizeof(char *), 1);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x12ff7
testl %eax, %eax
jne 0x930f
testq %rbx, %rbx
jne 0x9276
movl $0x8, %esi
movq %r15, %rdi
callq 0x11dba
movq %rax, %rbx
testq %rax, %rax
je 0x92d2
movq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x9292
cmpb $0x23, 0x1d198(%r15)
jne 0x92d7
leaq 0x1d198(%r15), %rsi
movl $0x8, %r8d
movq %r15, %rdi
movq %rbx, %rdx
movl $0x5, %ecx
movl $0x1, %r9d
callq 0x18fbf
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x930c
movq %r15, %rdi
movq %r14, %rsi
callq 0x131c3
testl %eax, %eax
je 0x930c
xorl %r13d, %r13d
jmp 0x930f
movq %r15, %rdi
callq 0x1c757
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x5, %r8d
movl $0x2, %r9d
pushq $-0x1
pushq $0x0
callq 0x1c3dc
addq $0x10, %rsp
movq %rax, (%rbx)
testq %rax, %rax
je 0x92d2
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_putindependent
SOAP_FMAC4 soap_putindependent(struct soap *soap)
{
	int i;
	struct soap_plist *pp;
	if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
		for (i = 0; i < SOAP_PTRHASH; i++)
			for (pp = soap->pht[i]; pp; pp = pp->next)
				if (pp->mark1 == 2 || pp->mark2 == 2)
					if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
						return soap->error;
	return SOAP_OK;
}

// Assembly:
xorl %eax, %eax
cmpw $0x1, 0x2(%rdi)
jne 0x958f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
je 0x9584
testb $0x6, 0x6(%rbx)
jne 0x9584
xorl %r15d, %r15d
leaq 0x1c29a(%rip), %r14     # 0x257c7
movq 0x3f20(%rbx,%r15,8), %r12
testq %r12, %r12
je 0x956e
cmpb $0x2, 0x20(%r12)
je 0x954a
cmpb $0x2, 0x21(%r12)
jne 0x9568
movq 0x8(%r12), %rsi
movl 0x1c(%r12), %ecx
movl 0x18(%r12), %r8d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9590
testl %eax, %eax
jne 0x957e
movq (%r12), %r12
jmp 0x9535
incq %r15
xorl %eax, %eax
cmpq $0x1000, %r15           # imm = 0x1000
jne 0x952d
jmp 0x9584
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__AppSequenceType
SOAP_FMAC4 soap_out_d__AppSequenceType(struct soap *soap, const char *tag, int id, const struct d__AppSequenceType *a, const char *type)
{
	soap_set_attr(soap, "InstanceId", soap_unsignedInt2s(soap, a->InstanceId), 1);
	if (a->SequenceId)
		soap_set_attr(soap, "SequenceId", a->SequenceId, 1);
	soap_set_attr(soap, "MessageNumber", soap_unsignedInt2s(soap, a->MessageNumber), 1);
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__AppSequenceType), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rcx), %esi
callq 0x1f7ef
leaq 0x1bc41(%rip), %rsi     # 0x25880
movq %r14, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b77e
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x9c6d
leaq 0x1bc2b(%rip), %rsi     # 0x2588b
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1b77e
movl 0x10(%r12), %esi
movq %r14, %rdi
callq 0x1f7ef
leaq 0x1bc15(%rip), %rsi     # 0x25896
movq %r14, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b77e
movq 0x18(%r12), %rdx
testq %rdx, %rdx
je 0x9caf
leaq 0x1bc02(%rip), %rsi     # 0x258a4
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl $0x39, %ecx
callq 0x184d8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r15, %rcx
callq 0x18a13
testl %eax, %eax
je 0x9ce5
movl 0x1f274(%r14), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__SigType
SOAP_FMAC4 soap_out_d__SigType(struct soap *soap, const char *tag, int id, const struct d__SigType *a, const char *type)
{
	if (a->Scheme)
		soap_set_attr(soap, "Scheme", a->Scheme, 1);
	if (a->KeyId)
		soap_set_attr(soap, "KeyId", a->KeyId, 1);
	if (a->Refs)
		soap_set_attr(soap, "Refs", a->Refs, 1);
	if (a->Sig)
		soap_set_attr(soap, "Sig", a->Sig, 1);
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__SigType), type))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x9d2e
leaq 0x1bb91(%rip), %rsi     # 0x258b2
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x9d4b
leaq 0x1bb7b(%rip), %rsi     # 0x258b9
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x9d68
leaq 0x1bb64(%rip), %rsi     # 0x258bf
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x9d85
leaq 0x1bb4e(%rip), %rsi     # 0x258c6
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x9da2
leaq 0x1bb0f(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl $0x37, %ecx
callq 0x184d8
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
je 0x9dde
movl 0x1f274(%r15), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%r14)
je 0x9e1a
cmpl $0x0, (%r14)
jle 0x9e1a
xorl %r13d, %r13d
leaq 0x1ba5e(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0x9df7
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__SecurityType
SOAP_FMAC4 soap_out_d__SecurityType(struct soap *soap, const char *tag, int id, const struct d__SecurityType *a, const char *type)
{
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__SecurityType), type))
		return soap->error;
	if (soap_out_PointerTod__SigType(soap, "d:Sig", -1, &a->Sig, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x9e66
leaq 0x1ba4b(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x36, %ecx
callq 0x184d8
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0x9eae
leaq 0x1ba31(%rip), %rsi     # 0x258c4
leaq 0x1c754(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xafc8
testl %eax, %eax
je 0x9ebd
movl 0x1f274(%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__ResolveMatchesType
SOAP_FMAC4 soap_out_d__ResolveMatchesType(struct soap *soap, const char *tag, int id, const struct d__ResolveMatchesType *a, const char *type)
{
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__ResolveMatchesType), type))
		return soap->error;
	if (soap_out_PointerTod__ResolveMatchType(soap, "d:ResolveMatch", -1, &a->ResolveMatch, ""))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0xa0b2
leaq 0x1b7ff(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x33, %ecx
callq 0x184d8
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0xa0fa
leaq 0x1b817(%rip), %rsi     # 0x258f6
leaq 0x1c508(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xb027
testl %eax, %eax
je 0xa10f
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x10(%r15)
je 0xa14d
cmpl $0x0, 0x8(%r15)
jle 0xa14d
xorl %r13d, %r13d
leaq 0x1b72c(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x10(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq 0x8(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa129
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__ResolveType
SOAP_FMAC4 soap_out_d__ResolveType(struct soap *soap, const char *tag, int id, const struct d__ResolveType *a, const char *type)
{
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__ResolveType), type))
		return soap->error;
	soap_element_result(soap, "wsa:EndpointReference");
	if (soap_out__wsa__EndpointReference(soap, "wsa:EndpointReference", -1, &a->wsa__EndpointReference, ""))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rcx), %rdx
testq %rdx, %rdx
je 0xa19c
leaq 0x1b715(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x32, %ecx
callq 0x184d8
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0xa1f2
leaq 0x1b5be(%rip), %r12     # 0x25787
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c31b
leaq 0x1c413(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xa9f1
testl %eax, %eax
je 0xa207
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x48(%r15)
je 0xa245
cmpl $0x0, 0x40(%r15)
jle 0xa245
xorl %r13d, %r13d
leaq 0x1b634(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x48(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq 0x40(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa221
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__ProbeMatchesType
SOAP_FMAC4 soap_out_d__ProbeMatchesType(struct soap *soap, const char *tag, int id, const struct d__ProbeMatchesType *a, const char *type)
{
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__ProbeMatchesType), type))
		return soap->error;
	soap_element_result(soap, "-sizeProbeMatch");
	if (a->ProbeMatch)
	{	int i;
		for (i = 0; i < a->__sizeProbeMatch; i++)
			if (soap_out_d__ProbeMatchType(soap, "d:ProbeMatch", -1, a->ProbeMatch + i, ""))
				return soap->error;
	}
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0xa424
leaq 0x1b48d(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl $0x2f, %ecx
callq 0x184d8
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
je 0xa460
movl 0x1f274(%r15), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b49e(%rip), %rsi     # 0x25905
movq %r15, %rdi
callq 0x1c31b
cmpq $0x0, 0x8(%r14)
je 0xa4fa
cmpl $0x0, (%r14)
setg %bpl
jle 0xa4f1
movq 0x8(%r14), %rcx
leaq 0x1b486(%rip), %rsi     # 0x25915
leaq 0x1c158(%rip), %r8      # 0x265ee
movq %r15, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xa25e
testl %eax, %eax
jne 0xa4e8
movl $0x70, %ecx
xorl %r12d, %r12d
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
setl %bpl
jge 0xa4f1
leaq 0x70(%rcx), %r13
addq 0x8(%r14), %rcx
movq %r15, %rdi
leaq 0x1b445(%rip), %rsi     # 0x25915
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x1c112(%rip), %r8      # 0x265ee
callq 0xa25e
movq %r13, %rcx
testl %eax, %eax
je 0xa4af
movl 0x1f274(%r15), %eax
jmp 0xa4f1
testb %bpl, %bpl
jne 0xa451
cmpq $0x0, 0x18(%r14)
je 0xa538
cmpl $0x0, 0x10(%r14)
jle 0xa538
xorl %r13d, %r13d
leaq 0x1b341(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x18(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq 0x10(%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa514
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__ProbeType
SOAP_FMAC4 soap_out_d__ProbeType(struct soap *soap, const char *tag, int id, const struct d__ProbeType *a, const char *type)
{
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_d__ProbeType), type))
		return soap->error;
	if (soap_out_d__QNameListType(soap, "d:Types", -1, &a->Types, ""))
		return soap->error;
	if (soap_out_PointerTod__ScopesType(soap, "d:Scopes", -1, &a->Scopes, ""))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0xa587
leaq 0x1b32a(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x2e, %ecx
callq 0x184d8
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
jne 0xa5f8
leaq 0x1b316(%rip), %rsi     # 0x258ca
leaq 0x1c033(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
movl $0x24, %r9d
callq 0x20632
testl %eax, %eax
jne 0xa5f8
leaq 0x8(%r15), %rcx
leaq 0x1b2f2(%rip), %rsi     # 0x258d2
leaq 0x1c007(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb14a
testl %eax, %eax
je 0xa60d
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x18(%r15)
je 0xa64b
cmpl $0x0, 0x10(%r15)
jle 0xa64b
xorl %r13d, %r13d
leaq 0x1b22e(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x18(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq 0x10(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa627
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_d__ScopesType
SOAP_FMAC4 soap_out_d__ScopesType(struct soap *soap, const char *tag, int id, const struct d__ScopesType *a, const char *type)
{
	if (a->MatchBy)
		soap_set_attr(soap, "MatchBy", a->MatchBy, 1);
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	return soap_out_d__UriListType(soap, tag, id, &a->__item, "");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xa81d
leaq 0x1b112(%rip), %rsi     # 0x25922
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0xa83a
leaq 0x1b077(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
leaq 0x1bdad(%rip), %r8      # 0x265ee
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl $0x25, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20632
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_wsa__Relationship
SOAP_FMAC4 soap_out_wsa__Relationship(struct soap *soap, const char *tag, int id, const struct wsa__Relationship *a, const char *type)
{
	if (a->RelationshipType)
		soap_set_attr(soap, "RelationshipType", soap_QName2s(soap, a->RelationshipType), 1);
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	return soap_out_string(soap, tag, id, &a->__item, "");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0xabdb
movq %r15, %rdi
callq 0x200e5
leaq 0x1a9a7(%rip), %rsi     # 0x25572
movq %r15, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b77e
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0xabf8
leaq 0x1acb9(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
leaq 0x1b9ef(%rip), %r8      # 0x265ee
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl $0x4, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20632
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_wsa__ServiceNameType
SOAP_FMAC4 soap_out_wsa__ServiceNameType(struct soap *soap, const char *tag, int id, const struct wsa__ServiceNameType *a, const char *type)
{
	const char *soap_tmp___item = soap_QName2s(soap, a->__item);
	if (a->PortName)
		soap_set_attr(soap, "PortName", a->PortName, 1);
	if (a->__anyAttribute)
		soap_set_attr(soap, "-anyAttribute", a->__anyAttribute, 1);
	return soap_out__QName(soap, tag, id, (char*const*)&soap_tmp___item, "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rcx), %rsi
callq 0x200e5
movq %rax, (%rsp)
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0xac5c
leaq 0x1acdb(%rip), %rsi     # 0x2592a
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
movq 0x10(%r12), %rdx
testq %rdx, %rdx
je 0xac7a
leaq 0x1ac37(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b77e
leaq 0x1b96d(%rip), %r8      # 0x265ee
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x5, %r9d
callq 0x20632
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_wsa__ReferenceParametersType
SOAP_FMAC4 soap_out_wsa__ReferenceParametersType(struct soap *soap, const char *tag, int id, const struct wsa__ReferenceParametersType *a, const char *type)
{
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wsa__ReferenceParametersType), type))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %esi
movq %rcx, %rdx
movl $0x9, %ecx
callq 0x184d8
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
je 0xacf3
movl 0x1f274(%r15), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%r14)
je 0xad2f
cmpl $0x0, (%r14)
jle 0xad2f
xorl %r13d, %r13d
leaq 0x1ab49(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xad0c
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_wsa__ReferencePropertiesType
SOAP_FMAC4 soap_out_wsa__ReferencePropertiesType(struct soap *soap, const char *tag, int id, const struct wsa__ReferencePropertiesType *a, const char *type)
{
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wsa__ReferencePropertiesType), type))
		return soap->error;
	if (a->__any)
	{	int i;
		for (i = 0; i < a->__size; i++)
			soap_outliteral(soap, "-any", a->__any + i, NULL);
	}
	return soap_element_end_out(soap, tag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %esi
movq %rcx, %rdx
movl $0x8, %ecx
callq 0x184d8
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x18a13
testl %eax, %eax
je 0xad98
movl 0x1f274(%r15), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%r14)
je 0xadd4
cmpl $0x0, (%r14)
jle 0xadd4
xorl %r13d, %r13d
leaq 0x1aaa4(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x20ddd
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xadb1
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a90
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_PointerTounsignedInt
SOAP_FMAC4 soap_out_PointerTounsignedInt(struct soap *soap, const char *tag, int id, unsigned int *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_unsignedInt);
	if (id < 0)
		return soap->error;
	return soap_out_unsignedInt(soap, tag, id, *a, type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1b
pushq %rbx
callq 0x1889b
addq $0x10, %rsp
testl %eax, %eax
js 0xb136
movq (%r15), %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %r8
movl $0x1b, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f80f
movl 0x1f274(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_PointerTod__ScopesType
SOAP_FMAC4 soap_out_PointerTod__ScopesType(struct soap *soap, const char *tag, int id, struct d__ScopesType *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_d__ScopesType);
	if (id < 0)
		return soap->error;
	return soap_out_d__ScopesType(soap, tag, id, *a, type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rax
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rcx), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x2a
pushq %rax
callq 0x1889b
addq $0x10, %rsp
testl %eax, %eax
js 0xb189
movq (%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa7ee
movl 0x1f274(%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_PointerTo_wsa__FaultTo
SOAP_FMAC4 soap_out_PointerTo_wsa__FaultTo(struct soap *soap, const char *tag, int id, struct wsa__EndpointReferenceType *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wsa__FaultTo);
	if (id < 0)
		return soap->error;
	return soap_out__wsa__FaultTo(soap, tag, id, *a, type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1a
pushq %rbx
callq 0x1889b
addq $0x10, %rsp
testl %eax, %eax
js 0xb1ec
movq (%r15), %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa9f1
movl 0x1f274(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_out_PointerTowsa__ReferenceParametersType
SOAP_FMAC4 soap_out_PointerTowsa__ReferenceParametersType(struct soap *soap, const char *tag, int id, struct wsa__ReferenceParametersType *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wsa__ReferenceParametersType);
	if (id < 0)
		return soap->error;
	return soap_out_wsa__ReferenceParametersType(soap, tag, id, *a, type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x9
pushq %rbx
callq 0x1889b
addq $0x10, %rsp
testl %eax, %eax
js 0xb406
movq (%r15), %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaca3
movl 0x1f274(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_d__ResolveMatchType
SOAP_FMAC4 soap_serialize_d__ResolveMatchType(struct soap *soap, const struct d__ResolveMatchType *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__wsa__EndpointReference(soap, &a->wsa__EndpointReference);
	soap_serialize_d__QNameListType(soap, &a->Types);
	soap_serialize_PointerTod__ScopesType(soap, &a->Scopes);
	soap_serialize_d__UriListType(soap, &a->XAddrs);
	soap_embedded(soap, &a->MetadataVersion, SOAP_TYPE_unsignedInt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb75d
movq 0x40(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0xb978
movq 0x50(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
addq $0x58, %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18377
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_d__ProbeMatchesType
SOAP_FMAC4 soap_serialize_d__ProbeMatchesType(struct soap *soap, const struct d__ProbeMatchesType *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	if (a->ProbeMatch)
	{	int i;
		for (i = 0; i < a->__sizeProbeMatch; i++)
		{
			soap_embedded(soap, a->ProbeMatch + i, SOAP_TYPE_d__ProbeMatchType);
			soap_serialize_d__ProbeMatchType(soap, a->ProbeMatch + i);
		}
	}
}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0xb675
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jle 0xb66a
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
movl $0x30, %edx
callq 0x18377
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0xb5c0
incq %r12
movslq (%rbx), %rax
addq $0x70, %r15
cmpq %rax, %r12
jl 0xb638
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_d__ByeType
SOAP_FMAC4 soap_serialize_d__ByeType(struct soap *soap, const struct d__ByeType *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize__wsa__EndpointReference(soap, &a->wsa__EndpointReference);
	soap_serialize_d__QNameListType(soap, &a->Types);
	soap_serialize_PointerTod__ScopesType(soap, &a->Scopes);
	soap_serialize_d__UriListType(soap, &a->XAddrs);
	soap_serialize_PointerTounsignedInt(soap, &a->MetadataVersion);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb75d
movq 0x40(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0xb978
movq 0x50(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x183b9
movq 0x58(%rbx), %rsi
movq %r14, %rdi
movl $0x1b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x183b9
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_serialize_wsa__EndpointReferenceType
SOAP_FMAC4 soap_serialize_wsa__EndpointReferenceType(struct soap *soap, const struct wsa__EndpointReferenceType *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_serialize_string(soap, &a->Address);
	soap_serialize_PointerTowsa__ReferencePropertiesType(soap, &a->ReferenceProperties);
	soap_serialize_PointerTowsa__ReferenceParametersType(soap, &a->ReferenceParameters);
	soap_serialize_PointerTo_QName(soap, &a->PortType);
	soap_serialize_PointerTowsa__ServiceNameType(soap, &a->ServiceName);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movl $0x4, %edx
callq 0x183b9
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x183b9
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x9, %edx
callq 0x183b9
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xbadb
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba9e
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_put_unsignedInt
SOAP_FMAC4 soap_put_unsignedInt(struct soap *soap, const unsigned int *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedInt);
	if (soap_out_unsignedInt(soap, tag?tag:"unsignedInt", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
movl $0x1b, %r9d
callq 0x17cd3
testq %r15, %r15
leaq 0x19882(%rip), %rsi     # 0x25554
cmovneq %r15, %rsi
movq %rbx, %rdi
movl %eax, %edx
movq %r12, %rcx
movq %r14, %r8
movl $0x1b, %r9d
callq 0x1f80f
testl %eax, %eax
je 0xbd02
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x94fe
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_s2d__FaultCodeType
SOAP_FMAC4S soap_s2d__FaultCodeType(struct soap *soap, const char *s, enum d__FaultCodeType *a)
{
	const struct soap_code_map *map;
	char *t;
	if (!s)
		return soap->error;
	soap_s2QName(soap, s, &t, 0, -1);
	map = soap_code(soap_codes_d__FaultCodeType, t);
	if (map)
		*a = (enum d__FaultCodeType)map->code;
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 0)))
			return soap->error = SOAP_TYPE;
		*a = (enum d__FaultCodeType)n;
	}
	return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
testq %rsi, %rsi
je 0xbde1
movq %rdx, %r14
movq %rsi, %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
movq $-0x1, %r8
callq 0x1d3cd
movq (%r13), %rsi
leaq 0x275f0(%rip), %rdi     # 0x333c0
callq 0x10d0d
testq %rax, %rax
je 0xbdea
movl (%rax), %eax
movl %eax, (%r14)
jmp 0xbe27
movl 0x1f274(%r15), %ebx
jmp 0xbe27
movq %rsp, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1e093
testl %eax, %eax
jne 0xbe17
testb $0x10, 0x5(%r15)
sete %cl
movq (%rsp), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0xbe17
movl %eax, (%r14)
jmp 0xbe27
movl $0x4, 0x1f274(%r15)
movl $0x4, %ebx
movl %ebx, %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/soapC.c
// Function: soap_put_d__FaultCodeType
SOAP_FMAC4 soap_put_d__FaultCodeType(struct soap *soap, const enum d__FaultCodeType *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_d__FaultCodeType);
	if (soap_out_d__FaultCodeType(soap, tag?tag:"d:FaultCodeType", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
movl $0x28, %r9d
callq 0x17cd3
testq %r15, %r15
leaq 0x196f9(%rip), %rsi     # 0x25560
cmovneq %r15, %rsi
movq %rbx, %rdi
movl %eax, %edx
movq %r12, %rcx
movq %r14, %r8
callq 0x9a33
testl %eax, %eax
je 0xbe91
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x94fe
// File: /workspace/github_c_makefile_star2_O1/hkshenSmart[P]ONVIF-discovery_cs/soapC.c
// Function: soap_s2d__RelationshipType
SOAP_FMAC4S soap_s2d__RelationshipType(struct soap *soap, const char *s, enum d__RelationshipType *a)
{
	const struct soap_code_map *map;
	char *t;
	if (!s)
		return soap->error;
	soap_s2QName(soap, s, &t, 0, -1);
	map = soap_code(soap_codes_d__RelationshipType, t);
	if (map)
		*a = (enum d__RelationshipType)map->code;
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 0)))
			return soap->error = SOAP_TYPE;
		*a = (enum d__RelationshipType)n;
	}
	return SOAP_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
testq %rsi, %rsi
je 0xbf6a
movq %rdx, %r14
movq %rsi, %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
movq $-0x1, %r8
callq 0x1d3cd
movq (%r13), %rsi
leaq 0x27487(%rip), %rdi     # 0x333e0
callq 0x10d0d
testq %rax, %rax
je 0xbf73
movl (%rax), %eax
movl %eax, (%r14)
jmp 0xbfb0
movl 0x1f274(%r15), %ebx
jmp 0xbfb0
movq %rsp, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1e093
testl %eax, %eax
jne 0xbfa0
testb $0x10, 0x5(%r15)
sete %cl
movq (%rsp), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0xbfa0
movl %eax, (%r14)
jmp 0xbfb0
movl $0x4, 0x1f274(%r15)
movl $0x4, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq