LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/cinemast[P]sudoku/sudoku.c
// Function: get_filepath
static
void
get_filepath (char *            working_buffer,
              size_t            working_buffsize,
              const char *      default_name)
{
    char *          wbp = working_buffer;
    size_t          wbs = working_buffsize;
    const char *    dn  = default_name;
    /* Just for the sake of having shorter names. */
    assert (wbp != NULL && wbs > 0);
    if (wbp != NULL && wbs > 0) {

        if ('\0' == *wbp) {
            wbp[0] = '>';
            assert(dn != NULL && strlen(dn) < 6 + 3);
            if (0 == getcwd(wbp + 1,
                            (int)wbs - 1 - 1 - 6 - 3)) {
                /* The path is probably too long, use the filename alone. */
                strcpy(wbp + 1, dn);
            } else {
                if (dn != NULL) {
                    /* If the path would make it longer than the line length
                     * we can use just the filename. If the file name itself
                     * is too long, than we cannot avoid the wrap around, so
                     * it's better to be prepared for handling that.
                     */
                    if (strlen(wbp) + strlen(dn) > wbs) {
                        wbp[1] = '\0';
                    } else {
                        strcat(wbp, "/");
                    }
                    strcat(wbp, dn);
                }
            }
            wbp[wbs - 1] = '\0';
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8537
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8537
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x852d
movq %rdx, %r15
movb $0x3e, (%r14)
testq %rdx, %rdx
je 0x8556
movq %r15, %rdi
callq 0x2100
cmpq $0x9, %rax
jae 0x8556
leaq 0x1(%r14), %r12
leal -0xb(%rbx), %eax
movslq %eax, %rsi
movq %r12, %rdi
callq 0x21a0
testq %rax, %rax
je 0x8500
movq %r14, %rdi
callq 0x2100
movq %rax, %r13
movq %r15, %rdi
callq 0x2100
addq %r13, %rax
cmpq %rbx, %rax
jbe 0x850d
movb $0x0, (%r12)
jmp 0x851c
movq %r12, %rdi
movq %r15, %rsi
callq 0x2050
jmp 0x8527
movq %r14, %rdi
callq 0x2100
movw $0x2f, (%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2310
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x356a(%rip), %rdi      # 0xbaa8
leaq 0x24b5(%rip), %rsi      # 0xa9fa
leaq 0x3573(%rip), %rcx      # 0xbabf
movl $0xc5c, %edx            # imm = 0xC5C
callq 0x2160
leaq 0x3592(%rip), %rdi      # 0xbaef
leaq 0x2496(%rip), %rsi      # 0xa9fa
leaq 0x3554(%rip), %rcx      # 0xbabf
movl $0xc61, %edx            # imm = 0xC61
callq 0x2160
// File: /workspace/github_c_makefile_star2_O3/cinemast[P]sudoku/sudoku.c
// Function: el_show_actual_char
static
void
el_show_actual_char (edit_t *  ep)
{
    if (ep->m_0 <= ep->m_1 &&
        ep->m_1 <= ep->ecp &&
        ep->ecp <= ep->ecn) {

        int first_invisible = ep->m_1 + ep->x_mv;

        if (ep->ecp < first_invisible) {
            /* Display the character */
            mvaddch(ep->efy,
                    ep->ecp - ep->m_1 + ep->x_1,
                    ep->eb[ep->ecp]);
        } else {
            if (ep->ecp != first_invisible ||
                ep->eb[ep->ecp] != '\0') {
                /* This should never happen. */
                beep();
            }
        }
    } else {
        /* This should never happen. */
        beep();
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x40(%rdi), %eax
cmpl %eax, 0x3c(%rdi)
jg 0x8591
movq %rdi, %rbx
movslq 0x24(%rdi), %rdx
cmpl %eax, %edx
jl 0x8591
cmpl 0x20(%rbx), %edx
jle 0x859d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl 0x38(%rbx), %ecx
addl %eax, %ecx
cmpl %ecx, %edx
jge 0x85dc
movq 0x5a2b(%rip), %r14      # 0xdfd8
movq (%r14), %rdi
movl 0x1c(%rbx), %esi
subl %eax, %edx
addl 0x2c(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x85e9
movq (%r14), %rdi
movq (%rbx), %rax
movslq 0x24(%rbx), %rcx
movsbl (%rax,%rcx), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2300
cmpl %ecx, %edx
jne 0x8591
movq (%rbx), %rax
cmpb $0x0, (%rax,%rdx)
jne 0x8591
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/cinemast[P]sudoku/sudoku.c
// Function: el_highlight_in_overwrite_mode
static
void
el_highlight_in_overwrite_mode (edit_t *    ep)
{
    if (!ep->ins_mode) {
        /* Overwrite mode, highlight the character at the current position. */
        attron(A_BOLD);
        el_show_actual_char(ep);
        attroff(A_BOLD);
    }
}

// Assembly:
cmpl $0x0, 0x50(%rdi)
je 0x85f8
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x59d2(%rip), %r14      # 0xdfd8
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x8575
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2370
// File: /workspace/github_c_makefile_star2_O3/cinemast[P]sudoku/sudoku.c
// Function: el_adjust_markers
static
void
el_adjust_markers (edit_t *   ep)
{
    int first_invisible = ep->m_1 + ep->x_mv;
    if (ep->m_0 == ep->m_1) {
        /* The first visible is the first editable character. */
        if (ep->prompt != ep->dprompt) {
            /* Show the default prompt if it is not shown yet. */
            ep->prompt = ep->dprompt;
            mvaddch(ep->efy, ep->x_0, ep->prompt);
        }
    } else {
        /* The first visible is not the first editable character. */
        if (ep->prompt != '<') {
            ep->prompt = '<';
            /* Show the '<' prompt. */
            mvaddch(ep->efy, ep->x_0, ep->prompt);
        }
    }
    if (ep->ecn > first_invisible) {
        /* The last visible is not the last editable character. */
        if (ep->eol_mark != '<') {
            ep->eol_mark = '<';
            mvaddch(ep->efy, ep->x_3, ep->eol_mark);
        }
    } else {
        if (ep->eol_mark != ' ') {
            ep->eol_mark = ' ';
            mvaddch(ep->efy, ep->x_3, ep->eol_mark);
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
movl 0x38(%rdi), %ebp
addl %ecx, %ebp
movl 0x44(%rdi), %eax
cmpl %ecx, 0x3c(%rdi)
jne 0x8655
movl 0x48(%rbx), %ecx
cmpl %ecx, %eax
je 0x868d
movl %ecx, 0x44(%rbx)
jmp 0x8661
cmpl $0x3c, %eax
je 0x868d
movl $0x3c, 0x44(%rbx)
movq 0x5970(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x1c(%rbx), %esi
movl 0x28(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x868d
movq 0x5956(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x44(%rbx), %esi
callq 0x2300
movl 0x4c(%rbx), %eax
cmpl %ebp, 0x20(%rbx)
jle 0x86a3
cmpl $0x3c, %eax
je 0x86e1
movl $0x3c, 0x4c(%rbx)
jmp 0x86af
cmpl $0x20, %eax
je 0x86e1
movl $0x20, 0x4c(%rbx)
movq 0x5922(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x1c(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0x22d0
cmpl $-0x1, %eax
je 0x86e1
movq 0x5908(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movl 0x4c(%rbx), %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x8724
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x8712
movsbl (%rbx), %esi
movq %rdx, %rdi
callq 0x2120
testq %rax, %rax
je 0x8712
incq %rbx
decq %r14
testq %r14, %r14
je 0x8724
cmpb $0x20, (%rbx)
jne 0x8726
incq %rbx
decq %r14
jne 0x8717
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1806e
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xb95f
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xb92a
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xb8f5
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xb8c0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x1806e
movq 0x30(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1806e
// File: /workspace/github_c_makefile_star2_O3/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 0x1806e
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xc27e
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xc2ba
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xc2fd
movq 0x30(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
movq 0x38(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc27e
// File: /workspace/github_c_makefile_star2_O3/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 0x3e2f
cmpw $0x2, 0x2(%rbx)
movq 0xbf38(%rbx), %rax
jne 0x412f
movq 0x28(%rax), %rax
jmp 0x4133
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4202
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4226
testq %rax, %rax
jne 0x41dd
cmpl $0x0, 0x1f274(%rbx)
jne 0x4202
movq %rbx, %rdi
callq 0x4f63
testl %eax, %eax
je 0x41dd
movl 0x1f274(%rbx), %eax
cmpl $0x6, %eax
je 0x4212
cmpl $-0x1, %eax
jne 0x421e
movl $0x0, 0x1f274(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1214c
testl %eax, %eax
je 0x4f81
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x10, 0x5(%rbx)
je 0x4f91
cmpw $0x3, 0x1e5f0(%rbx)
jne 0x4ff9
leaq 0x1c998(%rbx), %r14
leaq 0x2081e(%rip), %rdx     # 0x257bd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140fd
testl %eax, %eax
je 0x4ff9
cmpb $0x0, 0x1cd98(%rbx)
je 0x4fc9
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x4226
testq %rax, %rax
jne 0x4f73
movw $0x0, 0x1e5f6(%rbx)
movq 0xc048(%rbx), %rax
testq %rax, %rax
je 0x500d
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
movl %eax, 0x1f274(%rbx)
testl %eax, %eax
jne 0x4f73
leaq 0x1f274(%rbx), %r14
jmp 0x501e
movl $0x3, 0x1f274(%rbx)
movl $0x3, %eax
jmp 0x4f79
leaq 0x1f274(%rbx), %r14
movl $0x0, 0x1f274(%rbx)
cmpw $0x0, 0xc166(%rbx)
je 0x4f73
incl 0xc168(%rbx)
movq %rbx, %rdi
callq 0x4f63
testl %eax, %eax
je 0x5032
cmpl $0x6, (%r14)
jne 0x4f73
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13038
movl %eax, 0x1f274(%rbx)
jmp 0x4f73
// File: /workspace/github_c_makefile_star2_O3/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 0x12e5d
testl %eax, %eax
jne 0x8bdf
testq %rbx, %rbx
jne 0x8b57
movl $0x8, %esi
movq %r15, %rdi
callq 0x11c92
movq %rax, %rbx
testq %rax, %rax
je 0x8bb0
movq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x8b73
cmpb $0x23, 0x1d198(%r15)
jne 0x8bb5
leaq 0x1d198(%r15), %rsi
movl $0x4, %r8d
movq %r15, %rdi
movq %rbx, %rdx
movl $0x1b, %ecx
xorl %r9d, %r9d
callq 0x18c55
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x8bdc
movq %r15, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
je 0x8bdc
xorl %r13d, %r13d
jmp 0x8bdf
movq %r15, %rdi
callq 0x1c134
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x1b, %r8d
callq 0x1f027
movq %rax, (%rbx)
testq %rax, %rax
je 0x8bb0
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12e5d
testl %eax, %eax
jne 0x9246
testq %rbx, %rbx
jne 0x91ad
movl $0x8, %esi
movq %r15, %rdi
callq 0x11c92
movq %rax, %rbx
testq %rax, %rax
je 0x9209
movq $0x0, (%rbx)
cmpw $0x0, 0x1e5ec(%r15)
jne 0x91c9
cmpb $0x23, 0x1d198(%r15)
jne 0x920e
leaq 0x1d198(%r15), %rsi
movl $0x8, %r8d
movq %r15, %rdi
movq %rbx, %rdx
movl $0x5, %ecx
movl $0x1, %r9d
callq 0x18c55
movq %rax, %rbx
cmpw $0x0, 0xc166(%r15)
je 0x9243
movq %r15, %rdi
movq %r14, %rsi
callq 0x13038
testl %eax, %eax
je 0x9243
xorl %r13d, %r13d
jmp 0x9246
movq %r15, %rdi
callq 0x1c134
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x5, %r8d
movl $0x2, %r9d
pushq $-0x1
pushq $0x0
callq 0x1bdc7
addq $0x10, %rsp
movq %rax, (%rbx)
testq %rax, %rax
je 0x9209
movq %rbx, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x94c6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
je 0x94bb
testb $0x6, 0x6(%rbx)
jne 0x94bb
xorl %r15d, %r15d
leaq 0x1c363(%rip), %r14     # 0x257c7
movq 0x3f20(%rbx,%r15,8), %r12
testq %r12, %r12
je 0x94a5
cmpb $0x2, 0x20(%r12)
je 0x9481
cmpb $0x2, 0x21(%r12)
jne 0x949f
movq 0x8(%r12), %rsi
movl 0x1c(%r12), %ecx
movl 0x18(%r12), %r8d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x94c7
testl %eax, %eax
jne 0x94b5
movq (%r12), %r12
jmp 0x946c
incq %r15
xorl %eax, %eax
cmpq $0x1000, %r15           # imm = 0x1000
jne 0x9464
jmp 0x94bb
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ef03
leaq 0x1bd0a(%rip), %rsi     # 0x25880
movq %r14, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b1a4
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x9ba4
leaq 0x1bcf4(%rip), %rsi     # 0x2588b
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movl 0x10(%r12), %esi
movq %r14, %rdi
callq 0x1ef03
leaq 0x1bcde(%rip), %rsi     # 0x25896
movq %r14, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b1a4
movq 0x18(%r12), %rdx
testq %rdx, %rdx
je 0x9be6
leaq 0x1bccb(%rip), %rsi     # 0x258a4
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl $0x39, %ecx
callq 0x1817e
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r15, %rcx
callq 0x186a5
testl %eax, %eax
je 0x9c1c
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 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0x9c65
leaq 0x1bc5a(%rip), %rsi     # 0x258b2
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x9c82
leaq 0x1bc44(%rip), %rsi     # 0x258b9
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x9c9f
leaq 0x1bc2d(%rip), %rsi     # 0x258bf
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x9cbc
leaq 0x1bc17(%rip), %rsi     # 0x258c6
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x9cd9
leaq 0x1bbd8(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl $0x37, %ecx
callq 0x1817e
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
je 0x9d15
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 0x9d51
cmpl $0x0, (%r14)
jle 0x9d51
xorl %r13d, %r13d
leaq 0x1bb27(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0x9d2e
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0x9d9d
leaq 0x1bb14(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x36, %ecx
callq 0x1817e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0x9de5
leaq 0x1bafa(%rip), %rsi     # 0x258c4
leaq 0x1c81d(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xaec6
testl %eax, %eax
je 0x9df4
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 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0x9fe9
leaq 0x1b8c8(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x33, %ecx
callq 0x1817e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0xa031
leaq 0x1b8e0(%rip), %rsi     # 0x258f6
leaq 0x1c5d1(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xaf25
testl %eax, %eax
je 0xa046
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 0xa084
cmpl $0x0, 0x8(%r15)
jle 0xa084
xorl %r13d, %r13d
leaq 0x1b7f5(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x10(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq 0x8(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa060
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0xa0d3
leaq 0x1b7de(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x32, %ecx
callq 0x1817e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0xa129
leaq 0x1b687(%rip), %r12     # 0x25787
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1bd06
leaq 0x1c4dc(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0xa8ef
testl %eax, %eax
je 0xa13e
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 0xa17c
cmpl $0x0, 0x40(%r15)
jle 0xa17c
xorl %r13d, %r13d
leaq 0x1b6fd(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x48(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq 0x40(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa158
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0xa35b
leaq 0x1b556(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x2f, %ecx
callq 0x1817e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
je 0xa396
movl 0x1f274(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, (%rsp)
leaq 0x1b564(%rip), %rsi     # 0x25905
movq %rbx, %rdi
callq 0x1bd06
cmpq $0x0, 0x8(%r15)
je 0xa3f6
cmpl $0x0, (%r15)
jle 0xa3f6
xorl %ebp, %ebp
leaq 0x1b556(%rip), %r12     # 0x25915
leaq 0x1c228(%rip), %r13     # 0x265ee
xorl %r14d, %r14d
movq 0x8(%r15), %rcx
addq %rbp, %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r13, %r8
callq 0xa195
testl %eax, %eax
jne 0xa381
incq %r14
movslq (%r15), %rax
addq $0x70, %rbp
cmpq %rax, %r14
jl 0xa3c9
cmpq $0x0, 0x18(%r15)
je 0xa435
cmpl $0x0, 0x10(%r15)
jle 0xa435
xorl %r14d, %r14d
leaq 0x1b445(%rip), %r12     # 0x25853
xorl %r13d, %r13d
movq 0x18(%r15), %rdx
addq %r14, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %r13
movslq 0x10(%r15), %rax
addq $0x8, %r14
cmpq %rax, %r13
jl 0xa411
movq %rbx, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0xa485
leaq 0x1b42c(%rip), %rsi     # 0x258a4
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl $0x2e, %ecx
callq 0x1817e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
jne 0xa4f6
leaq 0x1b418(%rip), %rsi     # 0x258ca
leaq 0x1c135(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
movl $0x24, %r9d
callq 0x1fcff
testl %eax, %eax
jne 0xa4f6
leaq 0x8(%r15), %rcx
leaq 0x1b3f4(%rip), %rsi     # 0x258d2
leaq 0x1c109(%rip), %r8      # 0x265ee
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb048
testl %eax, %eax
je 0xa50b
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 0xa549
cmpl $0x0, 0x10(%r15)
jle 0xa549
xorl %r13d, %r13d
leaq 0x1b330(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x18(%r15), %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq 0x10(%r15), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xa525
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0xa71b
leaq 0x1b214(%rip), %rsi     # 0x25922
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0xa738
leaq 0x1b179(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
leaq 0x1beaf(%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 0x1fcff
// File: /workspace/github_c_makefile_star2_O3/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 0xaad9
movq %r15, %rdi
callq 0x1f7e7
leaq 0x1aaa9(%rip), %rsi     # 0x25572
movq %r15, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b1a4
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0xaaf6
leaq 0x1adbb(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
leaq 0x1baf1(%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 0x1fcff
// File: /workspace/github_c_makefile_star2_O3/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 0x1f7e7
movq %rax, (%rsp)
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0xab5a
leaq 0x1addd(%rip), %rsi     # 0x2592a
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
movq 0x10(%r12), %rdx
testq %rdx, %rdx
je 0xab78
leaq 0x1ad39(%rip), %rsi     # 0x258a4
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1b1a4
leaq 0x1ba6f(%rip), %r8      # 0x265ee
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x5, %r9d
callq 0x1fcff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1817e
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
je 0xabf1
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 0xac2d
cmpl $0x0, (%r14)
jle 0xac2d
xorl %r13d, %r13d
leaq 0x1ac4b(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xac0a
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0x1817e
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x186a5
testl %eax, %eax
je 0xac96
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 0xacd2
cmpl $0x0, (%r14)
jle 0xacd2
xorl %r13d, %r13d
leaq 0x1aba6(%rip), %r12     # 0x25853
xorl %ebp, %ebp
movq 0x8(%r14), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x204a0
incq %rbp
movslq (%r14), %rax
addq $0x8, %r13
cmpq %rax, %rbp
jl 0xacaf
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18722
// File: /workspace/github_c_makefile_star2_O3/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 0x18530
addq $0x10, %rsp
testl %eax, %eax
js 0xb034
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 0x1ef23
movl 0x1f274(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18530
addq $0x10, %rsp
testl %eax, %eax
js 0xb087
movq (%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa6ec
movl 0x1f274(%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18530
addq $0x10, %rsp
testl %eax, %eax
js 0xb304
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 0xaba1
movl 0x1f274(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb65b
movq 0x40(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0xb876
movq 0x50(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
addq $0x58, %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18038
// File: /workspace/github_c_makefile_star2_O3/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 0xb573
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jle 0xb568
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
movl $0x30, %edx
callq 0x18038
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0xb4be
incq %r12
movslq (%rbx), %rax
addq $0x70, %r15
cmpq %rax, %r12
jl 0xb536
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb65b
movq 0x40(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0xb876
movq 0x50(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x1806e
movq 0x58(%rbx), %rsi
movq %r14, %rdi
movl $0x1b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1806e
// File: /workspace/github_c_makefile_star2_O3/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 0x1806e
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x1806e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x9, %edx
callq 0x1806e
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xb9d9
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb99c
// File: /workspace/github_c_makefile_star2_O3/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 0x179bb
testq %r15, %r15
leaq 0x19984(%rip), %rsi     # 0x25554
cmovneq %r15, %rsi
movq %rbx, %rdi
movl %eax, %edx
movq %r12, %rcx
movq %r14, %r8
movl $0x1b, %r9d
callq 0x1ef23
testl %eax, %eax
je 0xbc00
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 0x9435