/* crossC.cpp
   Generated by gSOAP 2.8.91 for cross.h

gSOAP XML Web services tools
Copyright (C) 2000-2018, Robert van Engelen, Genivia Inc. All Rights Reserved.
The soapcpp2 tool and its generated software are released under the GPL.
This program is released under the GPL with the additional exemption that
compiling, linking, and/or using OpenSSL is allowed.
--------------------------------------------------------------------------------
A commercial use license is available from Genivia Inc., contact@genivia.com
--------------------------------------------------------------------------------
*/

#if defined(__BORLANDC__)
#pragma option push -w-8060
#pragma option push -w-8004
#endif

#include "crossH.h"

SOAP_SOURCE_STAMP("@(#) crossC.cpp ver 2.8.91 2021-05-24 02:42:29 GMT")


#ifndef WITH_NOGLOBAL

SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
{
	soap->part = SOAP_IN_HEADER;
	soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", soap->header, NULL);
	soap->part = SOAP_END_HEADER;
	return soap->header == NULL;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
{
	if (soap->version && soap->header)
	{	soap->part = SOAP_IN_HEADER;
		if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, ""))
			return soap->error;
		soap->part = SOAP_END_HEADER;
	}
	return SOAP_OK;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
{
	if (soap->version && soap->header)
		soap_serialize_SOAP_ENV__Header(soap, soap->header);
}

SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
{
	if (soap->header == NULL)
	{	if ((soap->header = soap_new_SOAP_ENV__Header(soap)))
			soap_default_SOAP_ENV__Header(soap, soap->header);
	}
}

SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
{
	if (soap->fault == NULL)
	{	soap->fault = soap_new_SOAP_ENV__Fault(soap, -1);
		if (soap->fault == NULL)
			return;
	}
	if (soap->version == 2 && soap->fault->SOAP_ENV__Code == NULL)
		soap->fault->SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap, -1);
	if (soap->version == 2 && soap->fault->SOAP_ENV__Reason == NULL)
		soap->fault->SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap, -1);
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
{
	if (soap->fault)
		soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
{
	if (soap->fault)
		return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", "");
	return SOAP_OK;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
{
	return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
}

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
{
	soap_fault(soap);
	if (soap->fault == NULL)
		return NULL;
	if (soap->version == 2 && soap->fault->SOAP_ENV__Code)
		return (const char**)(void*)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
	return (const char**)(void*)&soap->fault->faultcode;
}

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
{
	soap_fault(soap);
	if (soap->fault == NULL)
		return NULL;
	if (soap->version == 2 && soap->fault->SOAP_ENV__Code)
	{	if (soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode == NULL)
		{	soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = soap_new_SOAP_ENV__Code(soap, -1);
			if (soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode == NULL)
				return NULL;
		}
		return (const char**)(void*)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
	}
	return (const char**)(void*)&soap->fault->faultcode;
}

SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_subcode(struct soap *soap)
{
	const char **s = soap_faultsubcode(soap);
	return s ? *s : NULL;
}

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
{
	soap_fault(soap);
	if (soap->fault == NULL)
		return NULL;
	if (soap->version == 2 && soap->fault->SOAP_ENV__Reason)
		return (const char**)(void*)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
	return (const char**)(void*)&soap->fault->faultstring;
}

SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_string(struct soap *soap)
{
	const char **s = soap_faultstring(soap);
	return s ? *s : NULL;
}

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
{
	soap_fault(soap);
	if (soap->fault == NULL)
		return NULL;
	if (soap->version == 2)
	{	if (soap->fault->SOAP_ENV__Detail == NULL)
			soap->fault->SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap, -1);
		return (const char**)(void*)&soap->fault->SOAP_ENV__Detail->__any;
	}
	if (soap->fault->detail == NULL)
		soap->fault->detail = soap_new_SOAP_ENV__Detail(soap, -1);
	return (const char**)(void*)&soap->fault->detail->__any;
}

SOAP_FMAC3 const char * SOAP_FMAC4 soap_fault_detail(struct soap *soap)
{
	const char **s = soap_faultdetail(soap);
	return s ? *s : NULL;
}

#endif

#ifndef WITH_NOIDREF
SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
{
	int t;
	if (soap->version == 1)
	{	for (;;)
		{	if (!soap_getelement(soap, NULL, &t))
				if ((soap->error && soap->error != SOAP_TAG_MISMATCH) || soap_ignore_element(soap))
					break;
		}
	}
	if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
		soap->error = SOAP_OK;
	return soap->error;
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, const char *tag, int *type)
{	(void)type;
	if (soap_peek_element(soap))
		return NULL;
#ifndef WITH_NOIDREF
	if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
		*type = soap_lookup_type(soap, soap->href);
	switch (*type)
	{
	case SOAP_TYPE_byte:
		return soap_in_byte(soap, tag, NULL, "xsd:byte");
	case SOAP_TYPE_int:
		return soap_in_int(soap, tag, NULL, "xsd:int");
	case SOAP_TYPE_std__string:
		return soap_in_std__string(soap, tag, NULL, "xsd:string");
	case SOAP_TYPE_PointerTo_WS1__escrowResendSrv:
		return soap_in_PointerTo_WS1__escrowResendSrv(soap, tag, NULL, "WS1:escrowResendSrv");
	case SOAP_TYPE_PointerTo_WS1__invokeSrv:
		return soap_in_PointerTo_WS1__invokeSrv(soap, tag, NULL, "WS1:invokeSrv");
	case SOAP_TYPE_PointerTo_WS1__regEAI:
		return soap_in_PointerTo_WS1__regEAI(soap, tag, NULL, "WS1:regEAI");
	case SOAP_TYPE_PointerTo_WS1__regSrv:
		return soap_in_PointerTo_WS1__regSrv(soap, tag, NULL, "WS1:regSrv");
	case SOAP_TYPE_PointerTo_WS1__getStandardDataNameList:
		return soap_in_PointerTo_WS1__getStandardDataNameList(soap, tag, NULL, "WS1:getStandardDataNameList");
	case SOAP_TYPE_PointerTo_WS1__getStandardServiceList:
		return soap_in_PointerTo_WS1__getStandardServiceList(soap, tag, NULL, "WS1:getStandardServiceList");
	case SOAP_TYPE_PointerTo_WS1__fpInvoke:
		return soap_in_PointerTo_WS1__fpInvoke(soap, tag, NULL, "WS1:fpInvoke");
	case SOAP_TYPE_PointerTo_WS1__getSrv:
		return soap_in_PointerTo_WS1__getSrv(soap, tag, NULL, "WS1:getSrv");
	case SOAP_TYPE_PointerTo_WS1__getProd:
		return soap_in_PointerTo_WS1__getProd(soap, tag, NULL, "WS1:getProd");
	case SOAP_TYPE_PointerTo_WS1__invokeMdm:
		return soap_in_PointerTo_WS1__invokeMdm(soap, tag, NULL, "WS1:invokeMdm");
	case SOAP_TYPE_PointerTo_WS1__invokeUnion:
		return soap_in_PointerTo_WS1__invokeUnion(soap, tag, NULL, "WS1:invokeUnion");
	case SOAP_TYPE_PointerTo_WS1__regProdAP:
		return soap_in_PointerTo_WS1__regProdAP(soap, tag, NULL, "WS1:regProdAP");
	case SOAP_TYPE_PointerTo_WS1__getProdList:
		return soap_in_PointerTo_WS1__getProdList(soap, tag, NULL, "WS1:getProdList");
	case SOAP_TYPE_PointerTo_WS1__getParamList:
		return soap_in_PointerTo_WS1__getParamList(soap, tag, NULL, "WS1:getParamList");
	case SOAP_TYPE_PointerTo_WS1__getEtlJobList:
		return soap_in_PointerTo_WS1__getEtlJobList(soap, tag, NULL, "WS1:getEtlJobList");
	case SOAP_TYPE_PointerTo_WS1__invokeEtl:
		return soap_in_PointerTo_WS1__invokeEtl(soap, tag, NULL, "WS1:invokeEtl");
	case SOAP_TYPE__QName:
	{	char **s;
		s = soap_in__QName(soap, tag, NULL, "xsd:QName");
		return s ? *s : NULL;
	}
	case SOAP_TYPE_string:
	{	char **s;
		s = soap_in_string(soap, tag, NULL, "xsd:string");
		return s ? *s : NULL;
	}
	default:
#else
	*type = 0;
#endif
	{	const char *t = soap->type;
		if (!*t)
			t = soap->tag;
		if (!soap_match_tag(soap, t, "xsd:string"))
		{	*type = SOAP_TYPE_std__string;
			return soap_in_std__string(soap, tag, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:byte"))
		{	*type = SOAP_TYPE_byte;
			return soap_in_byte(soap, tag, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:int"))
		{	*type = SOAP_TYPE_int;
			return soap_in_int(soap, tag, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:QName"))
		{	char **s;
			*type = SOAP_TYPE__QName;
			s = soap_in__QName(soap, tag, NULL, NULL);
			return s ? *s : NULL;
		}
		if (!soap_match_tag(soap, t, "xsd:string"))
		{	char **s;
			*type = SOAP_TYPE_string;
			s = soap_in_string(soap, tag, NULL, NULL);
			return s ? *s : NULL;
		}
		t = soap->tag;
		if (!soap_match_tag(soap, t, "WS1:escrowResendSrvResponse"))
		{	*type = SOAP_TYPE__WS1__escrowResendSrvResponse;
			return soap_in__WS1__escrowResendSrvResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:escrowResendSrv"))
		{	*type = SOAP_TYPE__WS1__escrowResendSrv;
			return soap_in__WS1__escrowResendSrv(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeSrvResponse"))
		{	*type = SOAP_TYPE__WS1__invokeSrvResponse;
			return soap_in__WS1__invokeSrvResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeSrv"))
		{	*type = SOAP_TYPE__WS1__invokeSrv;
			return soap_in__WS1__invokeSrv(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regEAIResponse"))
		{	*type = SOAP_TYPE__WS1__regEAIResponse;
			return soap_in__WS1__regEAIResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regEAI"))
		{	*type = SOAP_TYPE__WS1__regEAI;
			return soap_in__WS1__regEAI(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regSrvResponse"))
		{	*type = SOAP_TYPE__WS1__regSrvResponse;
			return soap_in__WS1__regSrvResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regSrv"))
		{	*type = SOAP_TYPE__WS1__regSrv;
			return soap_in__WS1__regSrv(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getStandardDataNameListResponse"))
		{	*type = SOAP_TYPE__WS1__getStandardDataNameListResponse;
			return soap_in__WS1__getStandardDataNameListResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getStandardDataNameList"))
		{	*type = SOAP_TYPE__WS1__getStandardDataNameList;
			return soap_in__WS1__getStandardDataNameList(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getStandardServiceListResponse"))
		{	*type = SOAP_TYPE__WS1__getStandardServiceListResponse;
			return soap_in__WS1__getStandardServiceListResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getStandardServiceList"))
		{	*type = SOAP_TYPE__WS1__getStandardServiceList;
			return soap_in__WS1__getStandardServiceList(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:fpInvokeResponse"))
		{	*type = SOAP_TYPE__WS1__fpInvokeResponse;
			return soap_in__WS1__fpInvokeResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:fpInvoke"))
		{	*type = SOAP_TYPE__WS1__fpInvoke;
			return soap_in__WS1__fpInvoke(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getSrvResponse"))
		{	*type = SOAP_TYPE__WS1__getSrvResponse;
			return soap_in__WS1__getSrvResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getSrv"))
		{	*type = SOAP_TYPE__WS1__getSrv;
			return soap_in__WS1__getSrv(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getProdResponse"))
		{	*type = SOAP_TYPE__WS1__getProdResponse;
			return soap_in__WS1__getProdResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getProd"))
		{	*type = SOAP_TYPE__WS1__getProd;
			return soap_in__WS1__getProd(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeMdmResponse"))
		{	*type = SOAP_TYPE__WS1__invokeMdmResponse;
			return soap_in__WS1__invokeMdmResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeMdm"))
		{	*type = SOAP_TYPE__WS1__invokeMdm;
			return soap_in__WS1__invokeMdm(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeUnionResponse"))
		{	*type = SOAP_TYPE__WS1__invokeUnionResponse;
			return soap_in__WS1__invokeUnionResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeUnion"))
		{	*type = SOAP_TYPE__WS1__invokeUnion;
			return soap_in__WS1__invokeUnion(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regProdAPResponse"))
		{	*type = SOAP_TYPE__WS1__regProdAPResponse;
			return soap_in__WS1__regProdAPResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:regProdAP"))
		{	*type = SOAP_TYPE__WS1__regProdAP;
			return soap_in__WS1__regProdAP(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getProdListResponse"))
		{	*type = SOAP_TYPE__WS1__getProdListResponse;
			return soap_in__WS1__getProdListResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getProdList"))
		{	*type = SOAP_TYPE__WS1__getProdList;
			return soap_in__WS1__getProdList(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getParamListResponse"))
		{	*type = SOAP_TYPE__WS1__getParamListResponse;
			return soap_in__WS1__getParamListResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getParamList"))
		{	*type = SOAP_TYPE__WS1__getParamList;
			return soap_in__WS1__getParamList(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getEtlJobListResponse"))
		{	*type = SOAP_TYPE__WS1__getEtlJobListResponse;
			return soap_in__WS1__getEtlJobListResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:getEtlJobList"))
		{	*type = SOAP_TYPE__WS1__getEtlJobList;
			return soap_in__WS1__getEtlJobList(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeEtlResponse"))
		{	*type = SOAP_TYPE__WS1__invokeEtlResponse;
			return soap_in__WS1__invokeEtlResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "WS1:invokeEtl"))
		{	*type = SOAP_TYPE__WS1__invokeEtl;
			return soap_in__WS1__invokeEtl(soap, NULL, NULL, NULL);
		}
#ifndef WITH_NOIDREF
	}
#endif
	}
	soap->error = SOAP_TAG_MISMATCH;
	return NULL;
}

#ifdef __cplusplus
}
#endif

SOAP_FMAC3 int 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->mustUnderstand && !soap->other && !soap->fignore)
			return soap->error = SOAP_MUSTUNDERSTAND;
		if (((soap->mode & SOAP_XML_STRICT) && !soap->fignore && 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, NULL, &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_ignore(soap))
				return soap->error;
		}
	}
	return soap->error;
}

#ifndef WITH_NOIDREF
SOAP_FMAC3 int 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, SOAP_MULTIREFTAG, pp->id, pp->type))
						return soap->error;
	return SOAP_OK;
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
{	(void)tag;
	switch (type)
	{
	case SOAP_TYPE_byte:
		return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
	case SOAP_TYPE_int:
		return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
	case SOAP_TYPE_std__string:
		return soap_out_std__string(soap, tag, id, (const std::string *)ptr, "xsd:string");
	case SOAP_TYPE__WS1__escrowResendSrvResponse:
		return ((_WS1__escrowResendSrvResponse *)ptr)->soap_out(soap, "WS1:escrowResendSrvResponse", id, "");
	case SOAP_TYPE__WS1__escrowResendSrv:
		return ((_WS1__escrowResendSrv *)ptr)->soap_out(soap, "WS1:escrowResendSrv", id, "");
	case SOAP_TYPE__WS1__invokeSrvResponse:
		return ((_WS1__invokeSrvResponse *)ptr)->soap_out(soap, "WS1:invokeSrvResponse", id, "");
	case SOAP_TYPE__WS1__invokeSrv:
		return ((_WS1__invokeSrv *)ptr)->soap_out(soap, "WS1:invokeSrv", id, "");
	case SOAP_TYPE__WS1__regEAIResponse:
		return ((_WS1__regEAIResponse *)ptr)->soap_out(soap, "WS1:regEAIResponse", id, "");
	case SOAP_TYPE__WS1__regEAI:
		return ((_WS1__regEAI *)ptr)->soap_out(soap, "WS1:regEAI", id, "");
	case SOAP_TYPE__WS1__regSrvResponse:
		return ((_WS1__regSrvResponse *)ptr)->soap_out(soap, "WS1:regSrvResponse", id, "");
	case SOAP_TYPE__WS1__regSrv:
		return ((_WS1__regSrv *)ptr)->soap_out(soap, "WS1:regSrv", id, "");
	case SOAP_TYPE__WS1__getStandardDataNameListResponse:
		return ((_WS1__getStandardDataNameListResponse *)ptr)->soap_out(soap, "WS1:getStandardDataNameListResponse", id, "");
	case SOAP_TYPE__WS1__getStandardDataNameList:
		return ((_WS1__getStandardDataNameList *)ptr)->soap_out(soap, "WS1:getStandardDataNameList", id, "");
	case SOAP_TYPE__WS1__getStandardServiceListResponse:
		return ((_WS1__getStandardServiceListResponse *)ptr)->soap_out(soap, "WS1:getStandardServiceListResponse", id, "");
	case SOAP_TYPE__WS1__getStandardServiceList:
		return ((_WS1__getStandardServiceList *)ptr)->soap_out(soap, "WS1:getStandardServiceList", id, "");
	case SOAP_TYPE__WS1__fpInvokeResponse:
		return ((_WS1__fpInvokeResponse *)ptr)->soap_out(soap, "WS1:fpInvokeResponse", id, "");
	case SOAP_TYPE__WS1__fpInvoke:
		return ((_WS1__fpInvoke *)ptr)->soap_out(soap, "WS1:fpInvoke", id, "");
	case SOAP_TYPE__WS1__getSrvResponse:
		return ((_WS1__getSrvResponse *)ptr)->soap_out(soap, "WS1:getSrvResponse", id, "");
	case SOAP_TYPE__WS1__getSrv:
		return ((_WS1__getSrv *)ptr)->soap_out(soap, "WS1:getSrv", id, "");
	case SOAP_TYPE__WS1__getProdResponse:
		return ((_WS1__getProdResponse *)ptr)->soap_out(soap, "WS1:getProdResponse", id, "");
	case SOAP_TYPE__WS1__getProd:
		return ((_WS1__getProd *)ptr)->soap_out(soap, "WS1:getProd", id, "");
	case SOAP_TYPE__WS1__invokeMdmResponse:
		return ((_WS1__invokeMdmResponse *)ptr)->soap_out(soap, "WS1:invokeMdmResponse", id, "");
	case SOAP_TYPE__WS1__invokeMdm:
		return ((_WS1__invokeMdm *)ptr)->soap_out(soap, "WS1:invokeMdm", id, "");
	case SOAP_TYPE__WS1__invokeUnionResponse:
		return ((_WS1__invokeUnionResponse *)ptr)->soap_out(soap, "WS1:invokeUnionResponse", id, "");
	case SOAP_TYPE__WS1__invokeUnion:
		return ((_WS1__invokeUnion *)ptr)->soap_out(soap, "WS1:invokeUnion", id, "");
	case SOAP_TYPE__WS1__regProdAPResponse:
		return ((_WS1__regProdAPResponse *)ptr)->soap_out(soap, "WS1:regProdAPResponse", id, "");
	case SOAP_TYPE__WS1__regProdAP:
		return ((_WS1__regProdAP *)ptr)->soap_out(soap, "WS1:regProdAP", id, "");
	case SOAP_TYPE__WS1__getProdListResponse:
		return ((_WS1__getProdListResponse *)ptr)->soap_out(soap, "WS1:getProdListResponse", id, "");
	case SOAP_TYPE__WS1__getProdList:
		return ((_WS1__getProdList *)ptr)->soap_out(soap, "WS1:getProdList", id, "");
	case SOAP_TYPE__WS1__getParamListResponse:
		return ((_WS1__getParamListResponse *)ptr)->soap_out(soap, "WS1:getParamListResponse", id, "");
	case SOAP_TYPE__WS1__getParamList:
		return ((_WS1__getParamList *)ptr)->soap_out(soap, "WS1:getParamList", id, "");
	case SOAP_TYPE__WS1__getEtlJobListResponse:
		return ((_WS1__getEtlJobListResponse *)ptr)->soap_out(soap, "WS1:getEtlJobListResponse", id, "");
	case SOAP_TYPE__WS1__getEtlJobList:
		return ((_WS1__getEtlJobList *)ptr)->soap_out(soap, "WS1:getEtlJobList", id, "");
	case SOAP_TYPE__WS1__invokeEtlResponse:
		return ((_WS1__invokeEtlResponse *)ptr)->soap_out(soap, "WS1:invokeEtlResponse", id, "");
	case SOAP_TYPE__WS1__invokeEtl:
		return ((_WS1__invokeEtl *)ptr)->soap_out(soap, "WS1:invokeEtl", id, "");
	case SOAP_TYPE_PointerTo_WS1__escrowResendSrv:
		return soap_out_PointerTo_WS1__escrowResendSrv(soap, tag, id, (_WS1__escrowResendSrv *const*)ptr, "WS1:escrowResendSrv");
	case SOAP_TYPE_PointerTo_WS1__invokeSrv:
		return soap_out_PointerTo_WS1__invokeSrv(soap, tag, id, (_WS1__invokeSrv *const*)ptr, "WS1:invokeSrv");
	case SOAP_TYPE_PointerTo_WS1__regEAI:
		return soap_out_PointerTo_WS1__regEAI(soap, tag, id, (_WS1__regEAI *const*)ptr, "WS1:regEAI");
	case SOAP_TYPE_PointerTo_WS1__regSrv:
		return soap_out_PointerTo_WS1__regSrv(soap, tag, id, (_WS1__regSrv *const*)ptr, "WS1:regSrv");
	case SOAP_TYPE_PointerTo_WS1__getStandardDataNameList:
		return soap_out_PointerTo_WS1__getStandardDataNameList(soap, tag, id, (_WS1__getStandardDataNameList *const*)ptr, "WS1:getStandardDataNameList");
	case SOAP_TYPE_PointerTo_WS1__getStandardServiceList:
		return soap_out_PointerTo_WS1__getStandardServiceList(soap, tag, id, (_WS1__getStandardServiceList *const*)ptr, "WS1:getStandardServiceList");
	case SOAP_TYPE_PointerTo_WS1__fpInvoke:
		return soap_out_PointerTo_WS1__fpInvoke(soap, tag, id, (_WS1__fpInvoke *const*)ptr, "WS1:fpInvoke");
	case SOAP_TYPE_PointerTo_WS1__getSrv:
		return soap_out_PointerTo_WS1__getSrv(soap, tag, id, (_WS1__getSrv *const*)ptr, "WS1:getSrv");
	case SOAP_TYPE_PointerTo_WS1__getProd:
		return soap_out_PointerTo_WS1__getProd(soap, tag, id, (_WS1__getProd *const*)ptr, "WS1:getProd");
	case SOAP_TYPE_PointerTo_WS1__invokeMdm:
		return soap_out_PointerTo_WS1__invokeMdm(soap, tag, id, (_WS1__invokeMdm *const*)ptr, "WS1:invokeMdm");
	case SOAP_TYPE_PointerTo_WS1__invokeUnion:
		return soap_out_PointerTo_WS1__invokeUnion(soap, tag, id, (_WS1__invokeUnion *const*)ptr, "WS1:invokeUnion");
	case SOAP_TYPE_PointerTo_WS1__regProdAP:
		return soap_out_PointerTo_WS1__regProdAP(soap, tag, id, (_WS1__regProdAP *const*)ptr, "WS1:regProdAP");
	case SOAP_TYPE_PointerTo_WS1__getProdList:
		return soap_out_PointerTo_WS1__getProdList(soap, tag, id, (_WS1__getProdList *const*)ptr, "WS1:getProdList");
	case SOAP_TYPE_PointerTo_WS1__getParamList:
		return soap_out_PointerTo_WS1__getParamList(soap, tag, id, (_WS1__getParamList *const*)ptr, "WS1:getParamList");
	case SOAP_TYPE_PointerTo_WS1__getEtlJobList:
		return soap_out_PointerTo_WS1__getEtlJobList(soap, tag, id, (_WS1__getEtlJobList *const*)ptr, "WS1:getEtlJobList");
	case SOAP_TYPE_PointerTo_WS1__invokeEtl:
		return soap_out_PointerTo_WS1__invokeEtl(soap, tag, id, (_WS1__invokeEtl *const*)ptr, "WS1:invokeEtl");
	case SOAP_TYPE__QName:
		return soap_out_string(soap, tag, id, (char*const*)(void*)&ptr, "xsd:QName");
	case SOAP_TYPE_string:
		return soap_out_string(soap, tag, id, (char*const*)(void*)&ptr, "xsd:string");
	case 0:
		return SOAP_OK;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_putelement '%s' failed for type %d in crossC.cpp\n", tag ? tag : "", type));
	return soap_element_empty(soap, tag); /* unknown type to serialize */
}
#ifdef __cplusplus
}
#endif

#ifndef WITH_NOIDREF

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
{
	(void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */
	switch (type)
	{
	case SOAP_TYPE_std__string:
		soap_serialize_std__string(soap, (const std::string *)ptr);
		break;
	case SOAP_TYPE__WS1__escrowResendSrvResponse:
		((_WS1__escrowResendSrvResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__escrowResendSrv:
		((_WS1__escrowResendSrv *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeSrvResponse:
		((_WS1__invokeSrvResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeSrv:
		((_WS1__invokeSrv *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regEAIResponse:
		((_WS1__regEAIResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regEAI:
		((_WS1__regEAI *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regSrvResponse:
		((_WS1__regSrvResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regSrv:
		((_WS1__regSrv *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getStandardDataNameListResponse:
		((_WS1__getStandardDataNameListResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getStandardDataNameList:
		((_WS1__getStandardDataNameList *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getStandardServiceListResponse:
		((_WS1__getStandardServiceListResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getStandardServiceList:
		((_WS1__getStandardServiceList *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__fpInvokeResponse:
		((_WS1__fpInvokeResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__fpInvoke:
		((_WS1__fpInvoke *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getSrvResponse:
		((_WS1__getSrvResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getSrv:
		((_WS1__getSrv *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getProdResponse:
		((_WS1__getProdResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getProd:
		((_WS1__getProd *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeMdmResponse:
		((_WS1__invokeMdmResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeMdm:
		((_WS1__invokeMdm *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeUnionResponse:
		((_WS1__invokeUnionResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeUnion:
		((_WS1__invokeUnion *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regProdAPResponse:
		((_WS1__regProdAPResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__regProdAP:
		((_WS1__regProdAP *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getProdListResponse:
		((_WS1__getProdListResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getProdList:
		((_WS1__getProdList *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getParamListResponse:
		((_WS1__getParamListResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getParamList:
		((_WS1__getParamList *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getEtlJobListResponse:
		((_WS1__getEtlJobListResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__getEtlJobList:
		((_WS1__getEtlJobList *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeEtlResponse:
		((_WS1__invokeEtlResponse *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE__WS1__invokeEtl:
		((_WS1__invokeEtl *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE___WS1__escrowResendSrv:
		soap_serialize___WS1__escrowResendSrv(soap, (const struct __WS1__escrowResendSrv *)ptr);
		break;
	case SOAP_TYPE___WS1__invokeSrv:
		soap_serialize___WS1__invokeSrv(soap, (const struct __WS1__invokeSrv *)ptr);
		break;
	case SOAP_TYPE___WS1__regEAI:
		soap_serialize___WS1__regEAI(soap, (const struct __WS1__regEAI *)ptr);
		break;
	case SOAP_TYPE___WS1__regSrv:
		soap_serialize___WS1__regSrv(soap, (const struct __WS1__regSrv *)ptr);
		break;
	case SOAP_TYPE___WS1__getStandardDataNameList:
		soap_serialize___WS1__getStandardDataNameList(soap, (const struct __WS1__getStandardDataNameList *)ptr);
		break;
	case SOAP_TYPE___WS1__getStandardServiceList:
		soap_serialize___WS1__getStandardServiceList(soap, (const struct __WS1__getStandardServiceList *)ptr);
		break;
	case SOAP_TYPE___WS1__fpInvoke:
		soap_serialize___WS1__fpInvoke(soap, (const struct __WS1__fpInvoke *)ptr);
		break;
	case SOAP_TYPE___WS1__getSrv:
		soap_serialize___WS1__getSrv(soap, (const struct __WS1__getSrv *)ptr);
		break;
	case SOAP_TYPE___WS1__getProd:
		soap_serialize___WS1__getProd(soap, (const struct __WS1__getProd *)ptr);
		break;
	case SOAP_TYPE___WS1__invokeMdm:
		soap_serialize___WS1__invokeMdm(soap, (const struct __WS1__invokeMdm *)ptr);
		break;
	case SOAP_TYPE___WS1__invokeUnion:
		soap_serialize___WS1__invokeUnion(soap, (const struct __WS1__invokeUnion *)ptr);
		break;
	case SOAP_TYPE___WS1__regProdAP:
		soap_serialize___WS1__regProdAP(soap, (const struct __WS1__regProdAP *)ptr);
		break;
	case SOAP_TYPE___WS1__getProdList:
		soap_serialize___WS1__getProdList(soap, (const struct __WS1__getProdList *)ptr);
		break;
	case SOAP_TYPE___WS1__getParamList:
		soap_serialize___WS1__getParamList(soap, (const struct __WS1__getParamList *)ptr);
		break;
	case SOAP_TYPE___WS1__getEtlJobList:
		soap_serialize___WS1__getEtlJobList(soap, (const struct __WS1__getEtlJobList *)ptr);
		break;
	case SOAP_TYPE___WS1__invokeEtl:
		soap_serialize___WS1__invokeEtl(soap, (const struct __WS1__invokeEtl *)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__escrowResendSrv:
		soap_serialize_PointerTo_WS1__escrowResendSrv(soap, (_WS1__escrowResendSrv *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__invokeSrv:
		soap_serialize_PointerTo_WS1__invokeSrv(soap, (_WS1__invokeSrv *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__regEAI:
		soap_serialize_PointerTo_WS1__regEAI(soap, (_WS1__regEAI *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__regSrv:
		soap_serialize_PointerTo_WS1__regSrv(soap, (_WS1__regSrv *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getStandardDataNameList:
		soap_serialize_PointerTo_WS1__getStandardDataNameList(soap, (_WS1__getStandardDataNameList *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getStandardServiceList:
		soap_serialize_PointerTo_WS1__getStandardServiceList(soap, (_WS1__getStandardServiceList *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__fpInvoke:
		soap_serialize_PointerTo_WS1__fpInvoke(soap, (_WS1__fpInvoke *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getSrv:
		soap_serialize_PointerTo_WS1__getSrv(soap, (_WS1__getSrv *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getProd:
		soap_serialize_PointerTo_WS1__getProd(soap, (_WS1__getProd *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__invokeMdm:
		soap_serialize_PointerTo_WS1__invokeMdm(soap, (_WS1__invokeMdm *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__invokeUnion:
		soap_serialize_PointerTo_WS1__invokeUnion(soap, (_WS1__invokeUnion *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__regProdAP:
		soap_serialize_PointerTo_WS1__regProdAP(soap, (_WS1__regProdAP *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getProdList:
		soap_serialize_PointerTo_WS1__getProdList(soap, (_WS1__getProdList *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getParamList:
		soap_serialize_PointerTo_WS1__getParamList(soap, (_WS1__getParamList *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__getEtlJobList:
		soap_serialize_PointerTo_WS1__getEtlJobList(soap, (_WS1__getEtlJobList *const*)ptr);
		break;
	case SOAP_TYPE_PointerTo_WS1__invokeEtl:
		soap_serialize_PointerTo_WS1__invokeEtl(soap, (_WS1__invokeEtl *const*)ptr);
		break;
	case SOAP_TYPE__QName:
		soap_serialize_string(soap, (char*const*)(void*)&ptr);
		break;
	case SOAP_TYPE_string:
		soap_serialize_string(soap, (char*const*)(void*)&ptr);
		break;
	}
}
#ifdef __cplusplus
}
#endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

SOAP_FMAC3 void * SOAP_FMAC4 soap_dupelement(struct soap *soap, const void *ptr, int type)
{(void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */
	return NULL;
}
#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C" {
#endif

SOAP_FMAC3 void SOAP_FMAC4 soap_delelement(const void *ptr, int type)
{(void)ptr; (void)type; /* appease -Wall -Werror */
}
#ifdef __cplusplus
}
#endif

SOAP_FMAC3 void * SOAP_FMAC4 cross_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n)
{	(void)type;
	switch (t)
	{
	case SOAP_TYPE_std__string:
		return (void*)cross_instantiate_std__string(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeEtl:
		return (void*)cross_instantiate__WS1__invokeEtl(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeEtlResponse:
		return (void*)cross_instantiate__WS1__invokeEtlResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getEtlJobList:
		return (void*)cross_instantiate__WS1__getEtlJobList(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getEtlJobListResponse:
		return (void*)cross_instantiate__WS1__getEtlJobListResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getParamList:
		return (void*)cross_instantiate__WS1__getParamList(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getParamListResponse:
		return (void*)cross_instantiate__WS1__getParamListResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getProdList:
		return (void*)cross_instantiate__WS1__getProdList(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getProdListResponse:
		return (void*)cross_instantiate__WS1__getProdListResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regProdAP:
		return (void*)cross_instantiate__WS1__regProdAP(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regProdAPResponse:
		return (void*)cross_instantiate__WS1__regProdAPResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeUnion:
		return (void*)cross_instantiate__WS1__invokeUnion(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeUnionResponse:
		return (void*)cross_instantiate__WS1__invokeUnionResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeMdm:
		return (void*)cross_instantiate__WS1__invokeMdm(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeMdmResponse:
		return (void*)cross_instantiate__WS1__invokeMdmResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getProd:
		return (void*)cross_instantiate__WS1__getProd(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getProdResponse:
		return (void*)cross_instantiate__WS1__getProdResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getSrv:
		return (void*)cross_instantiate__WS1__getSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getSrvResponse:
		return (void*)cross_instantiate__WS1__getSrvResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__fpInvoke:
		return (void*)cross_instantiate__WS1__fpInvoke(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__fpInvokeResponse:
		return (void*)cross_instantiate__WS1__fpInvokeResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getStandardServiceList:
		return (void*)cross_instantiate__WS1__getStandardServiceList(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getStandardServiceListResponse:
		return (void*)cross_instantiate__WS1__getStandardServiceListResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getStandardDataNameList:
		return (void*)cross_instantiate__WS1__getStandardDataNameList(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__getStandardDataNameListResponse:
		return (void*)cross_instantiate__WS1__getStandardDataNameListResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regSrv:
		return (void*)cross_instantiate__WS1__regSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regSrvResponse:
		return (void*)cross_instantiate__WS1__regSrvResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regEAI:
		return (void*)cross_instantiate__WS1__regEAI(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__regEAIResponse:
		return (void*)cross_instantiate__WS1__regEAIResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeSrv:
		return (void*)cross_instantiate__WS1__invokeSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__invokeSrvResponse:
		return (void*)cross_instantiate__WS1__invokeSrvResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__escrowResendSrv:
		return (void*)cross_instantiate__WS1__escrowResendSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE__WS1__escrowResendSrvResponse:
		return (void*)cross_instantiate__WS1__escrowResendSrvResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__invokeEtl:
		return (void*)cross_instantiate___WS1__invokeEtl(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getEtlJobList:
		return (void*)cross_instantiate___WS1__getEtlJobList(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getParamList:
		return (void*)cross_instantiate___WS1__getParamList(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getProdList:
		return (void*)cross_instantiate___WS1__getProdList(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__regProdAP:
		return (void*)cross_instantiate___WS1__regProdAP(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__invokeUnion:
		return (void*)cross_instantiate___WS1__invokeUnion(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__invokeMdm:
		return (void*)cross_instantiate___WS1__invokeMdm(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getProd:
		return (void*)cross_instantiate___WS1__getProd(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getSrv:
		return (void*)cross_instantiate___WS1__getSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__fpInvoke:
		return (void*)cross_instantiate___WS1__fpInvoke(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getStandardServiceList:
		return (void*)cross_instantiate___WS1__getStandardServiceList(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__getStandardDataNameList:
		return (void*)cross_instantiate___WS1__getStandardDataNameList(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__regSrv:
		return (void*)cross_instantiate___WS1__regSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__regEAI:
		return (void*)cross_instantiate___WS1__regEAI(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__invokeSrv:
		return (void*)cross_instantiate___WS1__invokeSrv(soap, -1, type, arrayType, n);
	case SOAP_TYPE___WS1__escrowResendSrv:
		return (void*)cross_instantiate___WS1__escrowResendSrv(soap, -1, type, arrayType, n);
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Header:
		return (void*)cross_instantiate_SOAP_ENV__Header(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Code:
		return (void*)cross_instantiate_SOAP_ENV__Code(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Detail:
		return (void*)cross_instantiate_SOAP_ENV__Detail(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Reason:
		return (void*)cross_instantiate_SOAP_ENV__Reason(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Fault:
		return (void*)cross_instantiate_SOAP_ENV__Fault(soap, -1, type, arrayType, n);
#endif
	}
	return NULL;
}

SOAP_FMAC3 int SOAP_FMAC4 cross_fdelete(struct soap *soap, struct soap_clist *p)
{
	(void)soap; /* appease -Wall -Werror */
	if (!p->ptr)
		return SOAP_OK;
	switch (p->type)
	{
	case SOAP_TYPE_std__string:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<std::string*>(p->ptr), std::string);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<std::string*>(p->ptr), std::string);
		break;
	case SOAP_TYPE__WS1__invokeEtl:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeEtl*>(p->ptr), _WS1__invokeEtl);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeEtl*>(p->ptr), _WS1__invokeEtl);
		break;
	case SOAP_TYPE__WS1__invokeEtlResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeEtlResponse*>(p->ptr), _WS1__invokeEtlResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeEtlResponse*>(p->ptr), _WS1__invokeEtlResponse);
		break;
	case SOAP_TYPE__WS1__getEtlJobList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getEtlJobList*>(p->ptr), _WS1__getEtlJobList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getEtlJobList*>(p->ptr), _WS1__getEtlJobList);
		break;
	case SOAP_TYPE__WS1__getEtlJobListResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getEtlJobListResponse*>(p->ptr), _WS1__getEtlJobListResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getEtlJobListResponse*>(p->ptr), _WS1__getEtlJobListResponse);
		break;
	case SOAP_TYPE__WS1__getParamList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getParamList*>(p->ptr), _WS1__getParamList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getParamList*>(p->ptr), _WS1__getParamList);
		break;
	case SOAP_TYPE__WS1__getParamListResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getParamListResponse*>(p->ptr), _WS1__getParamListResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getParamListResponse*>(p->ptr), _WS1__getParamListResponse);
		break;
	case SOAP_TYPE__WS1__getProdList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getProdList*>(p->ptr), _WS1__getProdList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getProdList*>(p->ptr), _WS1__getProdList);
		break;
	case SOAP_TYPE__WS1__getProdListResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getProdListResponse*>(p->ptr), _WS1__getProdListResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getProdListResponse*>(p->ptr), _WS1__getProdListResponse);
		break;
	case SOAP_TYPE__WS1__regProdAP:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regProdAP*>(p->ptr), _WS1__regProdAP);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regProdAP*>(p->ptr), _WS1__regProdAP);
		break;
	case SOAP_TYPE__WS1__regProdAPResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regProdAPResponse*>(p->ptr), _WS1__regProdAPResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regProdAPResponse*>(p->ptr), _WS1__regProdAPResponse);
		break;
	case SOAP_TYPE__WS1__invokeUnion:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeUnion*>(p->ptr), _WS1__invokeUnion);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeUnion*>(p->ptr), _WS1__invokeUnion);
		break;
	case SOAP_TYPE__WS1__invokeUnionResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeUnionResponse*>(p->ptr), _WS1__invokeUnionResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeUnionResponse*>(p->ptr), _WS1__invokeUnionResponse);
		break;
	case SOAP_TYPE__WS1__invokeMdm:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeMdm*>(p->ptr), _WS1__invokeMdm);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeMdm*>(p->ptr), _WS1__invokeMdm);
		break;
	case SOAP_TYPE__WS1__invokeMdmResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeMdmResponse*>(p->ptr), _WS1__invokeMdmResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeMdmResponse*>(p->ptr), _WS1__invokeMdmResponse);
		break;
	case SOAP_TYPE__WS1__getProd:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getProd*>(p->ptr), _WS1__getProd);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getProd*>(p->ptr), _WS1__getProd);
		break;
	case SOAP_TYPE__WS1__getProdResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getProdResponse*>(p->ptr), _WS1__getProdResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getProdResponse*>(p->ptr), _WS1__getProdResponse);
		break;
	case SOAP_TYPE__WS1__getSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getSrv*>(p->ptr), _WS1__getSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getSrv*>(p->ptr), _WS1__getSrv);
		break;
	case SOAP_TYPE__WS1__getSrvResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getSrvResponse*>(p->ptr), _WS1__getSrvResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getSrvResponse*>(p->ptr), _WS1__getSrvResponse);
		break;
	case SOAP_TYPE__WS1__fpInvoke:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__fpInvoke*>(p->ptr), _WS1__fpInvoke);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__fpInvoke*>(p->ptr), _WS1__fpInvoke);
		break;
	case SOAP_TYPE__WS1__fpInvokeResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__fpInvokeResponse*>(p->ptr), _WS1__fpInvokeResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__fpInvokeResponse*>(p->ptr), _WS1__fpInvokeResponse);
		break;
	case SOAP_TYPE__WS1__getStandardServiceList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getStandardServiceList*>(p->ptr), _WS1__getStandardServiceList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getStandardServiceList*>(p->ptr), _WS1__getStandardServiceList);
		break;
	case SOAP_TYPE__WS1__getStandardServiceListResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getStandardServiceListResponse*>(p->ptr), _WS1__getStandardServiceListResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getStandardServiceListResponse*>(p->ptr), _WS1__getStandardServiceListResponse);
		break;
	case SOAP_TYPE__WS1__getStandardDataNameList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getStandardDataNameList*>(p->ptr), _WS1__getStandardDataNameList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getStandardDataNameList*>(p->ptr), _WS1__getStandardDataNameList);
		break;
	case SOAP_TYPE__WS1__getStandardDataNameListResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__getStandardDataNameListResponse*>(p->ptr), _WS1__getStandardDataNameListResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__getStandardDataNameListResponse*>(p->ptr), _WS1__getStandardDataNameListResponse);
		break;
	case SOAP_TYPE__WS1__regSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regSrv*>(p->ptr), _WS1__regSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regSrv*>(p->ptr), _WS1__regSrv);
		break;
	case SOAP_TYPE__WS1__regSrvResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regSrvResponse*>(p->ptr), _WS1__regSrvResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regSrvResponse*>(p->ptr), _WS1__regSrvResponse);
		break;
	case SOAP_TYPE__WS1__regEAI:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regEAI*>(p->ptr), _WS1__regEAI);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regEAI*>(p->ptr), _WS1__regEAI);
		break;
	case SOAP_TYPE__WS1__regEAIResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__regEAIResponse*>(p->ptr), _WS1__regEAIResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__regEAIResponse*>(p->ptr), _WS1__regEAIResponse);
		break;
	case SOAP_TYPE__WS1__invokeSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeSrv*>(p->ptr), _WS1__invokeSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeSrv*>(p->ptr), _WS1__invokeSrv);
		break;
	case SOAP_TYPE__WS1__invokeSrvResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__invokeSrvResponse*>(p->ptr), _WS1__invokeSrvResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__invokeSrvResponse*>(p->ptr), _WS1__invokeSrvResponse);
		break;
	case SOAP_TYPE__WS1__escrowResendSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__escrowResendSrv*>(p->ptr), _WS1__escrowResendSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__escrowResendSrv*>(p->ptr), _WS1__escrowResendSrv);
		break;
	case SOAP_TYPE__WS1__escrowResendSrvResponse:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<_WS1__escrowResendSrvResponse*>(p->ptr), _WS1__escrowResendSrvResponse);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<_WS1__escrowResendSrvResponse*>(p->ptr), _WS1__escrowResendSrvResponse);
		break;
	case SOAP_TYPE___WS1__invokeEtl:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__invokeEtl*>(p->ptr), struct __WS1__invokeEtl);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__invokeEtl*>(p->ptr), struct __WS1__invokeEtl);
		break;
	case SOAP_TYPE___WS1__getEtlJobList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getEtlJobList*>(p->ptr), struct __WS1__getEtlJobList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getEtlJobList*>(p->ptr), struct __WS1__getEtlJobList);
		break;
	case SOAP_TYPE___WS1__getParamList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getParamList*>(p->ptr), struct __WS1__getParamList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getParamList*>(p->ptr), struct __WS1__getParamList);
		break;
	case SOAP_TYPE___WS1__getProdList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getProdList*>(p->ptr), struct __WS1__getProdList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getProdList*>(p->ptr), struct __WS1__getProdList);
		break;
	case SOAP_TYPE___WS1__regProdAP:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__regProdAP*>(p->ptr), struct __WS1__regProdAP);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__regProdAP*>(p->ptr), struct __WS1__regProdAP);
		break;
	case SOAP_TYPE___WS1__invokeUnion:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__invokeUnion*>(p->ptr), struct __WS1__invokeUnion);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__invokeUnion*>(p->ptr), struct __WS1__invokeUnion);
		break;
	case SOAP_TYPE___WS1__invokeMdm:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__invokeMdm*>(p->ptr), struct __WS1__invokeMdm);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__invokeMdm*>(p->ptr), struct __WS1__invokeMdm);
		break;
	case SOAP_TYPE___WS1__getProd:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getProd*>(p->ptr), struct __WS1__getProd);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getProd*>(p->ptr), struct __WS1__getProd);
		break;
	case SOAP_TYPE___WS1__getSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getSrv*>(p->ptr), struct __WS1__getSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getSrv*>(p->ptr), struct __WS1__getSrv);
		break;
	case SOAP_TYPE___WS1__fpInvoke:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__fpInvoke*>(p->ptr), struct __WS1__fpInvoke);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__fpInvoke*>(p->ptr), struct __WS1__fpInvoke);
		break;
	case SOAP_TYPE___WS1__getStandardServiceList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getStandardServiceList*>(p->ptr), struct __WS1__getStandardServiceList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getStandardServiceList*>(p->ptr), struct __WS1__getStandardServiceList);
		break;
	case SOAP_TYPE___WS1__getStandardDataNameList:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__getStandardDataNameList*>(p->ptr), struct __WS1__getStandardDataNameList);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__getStandardDataNameList*>(p->ptr), struct __WS1__getStandardDataNameList);
		break;
	case SOAP_TYPE___WS1__regSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__regSrv*>(p->ptr), struct __WS1__regSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__regSrv*>(p->ptr), struct __WS1__regSrv);
		break;
	case SOAP_TYPE___WS1__regEAI:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__regEAI*>(p->ptr), struct __WS1__regEAI);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__regEAI*>(p->ptr), struct __WS1__regEAI);
		break;
	case SOAP_TYPE___WS1__invokeSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__invokeSrv*>(p->ptr), struct __WS1__invokeSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__invokeSrv*>(p->ptr), struct __WS1__invokeSrv);
		break;
	case SOAP_TYPE___WS1__escrowResendSrv:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct __WS1__escrowResendSrv*>(p->ptr), struct __WS1__escrowResendSrv);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct __WS1__escrowResendSrv*>(p->ptr), struct __WS1__escrowResendSrv);
		break;
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Header:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct SOAP_ENV__Header*>(p->ptr), struct SOAP_ENV__Header);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct SOAP_ENV__Header*>(p->ptr), struct SOAP_ENV__Header);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Code:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct SOAP_ENV__Code*>(p->ptr), struct SOAP_ENV__Code);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct SOAP_ENV__Code*>(p->ptr), struct SOAP_ENV__Code);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Detail:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct SOAP_ENV__Detail*>(p->ptr), struct SOAP_ENV__Detail);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct SOAP_ENV__Detail*>(p->ptr), struct SOAP_ENV__Detail);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Reason:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct SOAP_ENV__Reason*>(p->ptr), struct SOAP_ENV__Reason);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct SOAP_ENV__Reason*>(p->ptr), struct SOAP_ENV__Reason);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Fault:
		if (p->size < 0)
			SOAP_DELETE(soap, static_cast<struct SOAP_ENV__Fault*>(p->ptr), struct SOAP_ENV__Fault);
		else
			SOAP_DELETE_ARRAY(soap, static_cast<struct SOAP_ENV__Fault*>(p->ptr), struct SOAP_ENV__Fault);
		break;
#endif
	default:
		return SOAP_ERR;
	}
	return SOAP_OK;
}

#ifdef WIN32
#pragma warning(push)
// do not warn on switch w/o cases
#pragma warning(disable:4065)
#endif
SOAP_FMAC3 int SOAP_FMAC4 cross_fbase(int t, int b)
{
	(void)t; (void)b; /* appease -Wall -Werror */
	return 0;
}
#ifdef WIN32
#pragma warning(pop)
#endif

#ifndef WITH_NOIDREF
#ifdef WIN32
#pragma warning(push)
// do not warn on switch w/o cases
#pragma warning(disable:4065)
#endif
SOAP_FMAC3 void SOAP_FMAC4 cross_finsert(struct soap *soap, int t, int tt, void *p, size_t index, const void *q, void **x)
{
	(void)soap; (void)t; (void)p; (void)index; (void)q; (void)x; /* appease -Wall -Werror */
	switch (tt)
	{
	case SOAP_TYPE_std__string:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy std::string type=%d location=%p object=%p\n", t, p, q));
		*(std::string*)p = *(std::string*)q;
		break;
	case SOAP_TYPE__WS1__invokeEtl:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeEtl type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeEtl*)p = *(_WS1__invokeEtl*)q;
		break;
	case SOAP_TYPE__WS1__invokeEtlResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeEtlResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeEtlResponse*)p = *(_WS1__invokeEtlResponse*)q;
		break;
	case SOAP_TYPE__WS1__getEtlJobList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getEtlJobList type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getEtlJobList*)p = *(_WS1__getEtlJobList*)q;
		break;
	case SOAP_TYPE__WS1__getEtlJobListResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getEtlJobListResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getEtlJobListResponse*)p = *(_WS1__getEtlJobListResponse*)q;
		break;
	case SOAP_TYPE__WS1__getParamList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getParamList type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getParamList*)p = *(_WS1__getParamList*)q;
		break;
	case SOAP_TYPE__WS1__getParamListResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getParamListResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getParamListResponse*)p = *(_WS1__getParamListResponse*)q;
		break;
	case SOAP_TYPE__WS1__getProdList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getProdList type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getProdList*)p = *(_WS1__getProdList*)q;
		break;
	case SOAP_TYPE__WS1__getProdListResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getProdListResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getProdListResponse*)p = *(_WS1__getProdListResponse*)q;
		break;
	case SOAP_TYPE__WS1__regProdAP:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regProdAP type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regProdAP*)p = *(_WS1__regProdAP*)q;
		break;
	case SOAP_TYPE__WS1__regProdAPResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regProdAPResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regProdAPResponse*)p = *(_WS1__regProdAPResponse*)q;
		break;
	case SOAP_TYPE__WS1__invokeUnion:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeUnion type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeUnion*)p = *(_WS1__invokeUnion*)q;
		break;
	case SOAP_TYPE__WS1__invokeUnionResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeUnionResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeUnionResponse*)p = *(_WS1__invokeUnionResponse*)q;
		break;
	case SOAP_TYPE__WS1__invokeMdm:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeMdm type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeMdm*)p = *(_WS1__invokeMdm*)q;
		break;
	case SOAP_TYPE__WS1__invokeMdmResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeMdmResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeMdmResponse*)p = *(_WS1__invokeMdmResponse*)q;
		break;
	case SOAP_TYPE__WS1__getProd:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getProd type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getProd*)p = *(_WS1__getProd*)q;
		break;
	case SOAP_TYPE__WS1__getProdResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getProdResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getProdResponse*)p = *(_WS1__getProdResponse*)q;
		break;
	case SOAP_TYPE__WS1__getSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getSrv type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getSrv*)p = *(_WS1__getSrv*)q;
		break;
	case SOAP_TYPE__WS1__getSrvResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getSrvResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getSrvResponse*)p = *(_WS1__getSrvResponse*)q;
		break;
	case SOAP_TYPE__WS1__fpInvoke:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__fpInvoke type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__fpInvoke*)p = *(_WS1__fpInvoke*)q;
		break;
	case SOAP_TYPE__WS1__fpInvokeResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__fpInvokeResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__fpInvokeResponse*)p = *(_WS1__fpInvokeResponse*)q;
		break;
	case SOAP_TYPE__WS1__getStandardServiceList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getStandardServiceList type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getStandardServiceList*)p = *(_WS1__getStandardServiceList*)q;
		break;
	case SOAP_TYPE__WS1__getStandardServiceListResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getStandardServiceListResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getStandardServiceListResponse*)p = *(_WS1__getStandardServiceListResponse*)q;
		break;
	case SOAP_TYPE__WS1__getStandardDataNameList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getStandardDataNameList type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getStandardDataNameList*)p = *(_WS1__getStandardDataNameList*)q;
		break;
	case SOAP_TYPE__WS1__getStandardDataNameListResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__getStandardDataNameListResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__getStandardDataNameListResponse*)p = *(_WS1__getStandardDataNameListResponse*)q;
		break;
	case SOAP_TYPE__WS1__regSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regSrv type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regSrv*)p = *(_WS1__regSrv*)q;
		break;
	case SOAP_TYPE__WS1__regSrvResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regSrvResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regSrvResponse*)p = *(_WS1__regSrvResponse*)q;
		break;
	case SOAP_TYPE__WS1__regEAI:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regEAI type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regEAI*)p = *(_WS1__regEAI*)q;
		break;
	case SOAP_TYPE__WS1__regEAIResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__regEAIResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__regEAIResponse*)p = *(_WS1__regEAIResponse*)q;
		break;
	case SOAP_TYPE__WS1__invokeSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeSrv type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeSrv*)p = *(_WS1__invokeSrv*)q;
		break;
	case SOAP_TYPE__WS1__invokeSrvResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__invokeSrvResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__invokeSrvResponse*)p = *(_WS1__invokeSrvResponse*)q;
		break;
	case SOAP_TYPE__WS1__escrowResendSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__escrowResendSrv type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__escrowResendSrv*)p = *(_WS1__escrowResendSrv*)q;
		break;
	case SOAP_TYPE__WS1__escrowResendSrvResponse:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy _WS1__escrowResendSrvResponse type=%d location=%p object=%p\n", t, p, q));
		*(_WS1__escrowResendSrvResponse*)p = *(_WS1__escrowResendSrvResponse*)q;
		break;
	case SOAP_TYPE___WS1__invokeEtl:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__invokeEtl type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__invokeEtl*)p = *(struct __WS1__invokeEtl*)q;
		break;
	case SOAP_TYPE___WS1__getEtlJobList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getEtlJobList type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getEtlJobList*)p = *(struct __WS1__getEtlJobList*)q;
		break;
	case SOAP_TYPE___WS1__getParamList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getParamList type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getParamList*)p = *(struct __WS1__getParamList*)q;
		break;
	case SOAP_TYPE___WS1__getProdList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getProdList type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getProdList*)p = *(struct __WS1__getProdList*)q;
		break;
	case SOAP_TYPE___WS1__regProdAP:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__regProdAP type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__regProdAP*)p = *(struct __WS1__regProdAP*)q;
		break;
	case SOAP_TYPE___WS1__invokeUnion:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__invokeUnion type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__invokeUnion*)p = *(struct __WS1__invokeUnion*)q;
		break;
	case SOAP_TYPE___WS1__invokeMdm:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__invokeMdm type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__invokeMdm*)p = *(struct __WS1__invokeMdm*)q;
		break;
	case SOAP_TYPE___WS1__getProd:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getProd type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getProd*)p = *(struct __WS1__getProd*)q;
		break;
	case SOAP_TYPE___WS1__getSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getSrv type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getSrv*)p = *(struct __WS1__getSrv*)q;
		break;
	case SOAP_TYPE___WS1__fpInvoke:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__fpInvoke type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__fpInvoke*)p = *(struct __WS1__fpInvoke*)q;
		break;
	case SOAP_TYPE___WS1__getStandardServiceList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getStandardServiceList type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getStandardServiceList*)p = *(struct __WS1__getStandardServiceList*)q;
		break;
	case SOAP_TYPE___WS1__getStandardDataNameList:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__getStandardDataNameList type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__getStandardDataNameList*)p = *(struct __WS1__getStandardDataNameList*)q;
		break;
	case SOAP_TYPE___WS1__regSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__regSrv type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__regSrv*)p = *(struct __WS1__regSrv*)q;
		break;
	case SOAP_TYPE___WS1__regEAI:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__regEAI type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__regEAI*)p = *(struct __WS1__regEAI*)q;
		break;
	case SOAP_TYPE___WS1__invokeSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__invokeSrv type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__invokeSrv*)p = *(struct __WS1__invokeSrv*)q;
		break;
	case SOAP_TYPE___WS1__escrowResendSrv:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct __WS1__escrowResendSrv type=%d location=%p object=%p\n", t, p, q));
		*(struct __WS1__escrowResendSrv*)p = *(struct __WS1__escrowResendSrv*)q;
		break;
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Header:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct SOAP_ENV__Header type=%d location=%p object=%p\n", t, p, q));
		*(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Code:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct SOAP_ENV__Code type=%d location=%p object=%p\n", t, p, q));
		*(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Detail:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct SOAP_ENV__Detail type=%d location=%p object=%p\n", t, p, q));
		*(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Reason:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct SOAP_ENV__Reason type=%d location=%p object=%p\n", t, p, q));
		*(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Fault:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy struct SOAP_ENV__Fault type=%d location=%p object=%p\n", t, p, q));
		*(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;
		break;
#endif
	default:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not insert type=%d in %d\n", t, tt));
	}
}
#ifdef WIN32
#pragma warning(pop)
#endif
#endif

SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
{
	return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
}

SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
{
	a = soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
	return a;
}

SOAP_FMAC3 char * SOAP_FMAC4 soap_new_byte(struct soap *soap, int n)
{
	char *a = static_cast<char *>(soap_malloc(soap, (n = (n < 0 ? 1 : n)) * sizeof(char)));
	for (char *p = a; p && n--; ++p)
		soap_default_byte(soap, p);
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
{
	if (soap_out_byte(soap, tag ? tag : "byte", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
{
	if ((p = soap_in_byte(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
{
	return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
}

SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
{
	a = soap_inint(soap, tag, a, type, SOAP_TYPE_int);
	return a;
}

SOAP_FMAC3 int * SOAP_FMAC4 soap_new_int(struct soap *soap, int n)
{
	int *a = static_cast<int *>(soap_malloc(soap, (n = (n < 0 ? 1 : n)) * sizeof(int)));
	for (int *p = a; p && n--; ++p)
		soap_default_int(soap, p);
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
{
	if (soap_out_int(soap, tag ? tag : "int", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
{
	if ((p = soap_in_int(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__string(struct soap *soap, const std::string *a)
{	(void)soap; (void)a; /* appease -Wall -Werror */
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__string(struct soap *soap, const char *tag, int id, const std::string *s, const char *type)
{
	if ((soap->mode & SOAP_C_NILSTRING) && s->empty())
		return soap_element_null(soap, tag, id, type);
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_std__string), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_std__string(struct soap *soap, const char *tag, std::string *s, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!s)
		s = soap_new_std__string(soap, -1);
	if (soap->null)
		if (s)
			s->erase();
	if (soap->body && *soap->href != '#')
	{	char *t;
		s = (std::string*)soap_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
		if (s)
		{	if (!(t = soap_string_in(soap, 1, 0, -1, NULL)))
				return NULL;
			s->assign(t);
		}
	}
	else
		s = (std::string*)soap_id_forward(soap, soap->href, soap_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType, cross_instantiate, cross_fbase), 0, SOAP_TYPE_std__string, SOAP_TYPE_std__string, sizeof(std::string), 0, cross_finsert, NULL);
	if (soap->body && soap_element_end_in(soap, tag))
		return NULL;
	return s;
}

SOAP_FMAC1 std::string * SOAP_FMAC2 cross_instantiate_std__string(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_std__string(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	std::string *p;
	size_t k = sizeof(std::string);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_std__string, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, std::string);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, std::string, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated std::string location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_std__string(struct soap *soap, const std::string *a, const char *tag, const char *type)
{
	if (soap_out_std__string(soap, tag ? tag : "string", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_std__string(struct soap *soap, std::string *p, const char *tag, const char *type)
{
	if ((p = soap_in_std__string(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__escrowResendSrvResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__escrowResendSrvResponse::escrowResendSrvReturn);
}

void _WS1__escrowResendSrvResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__escrowResendSrvResponse::escrowResendSrvReturn);
#endif
}

int _WS1__escrowResendSrvResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__escrowResendSrvResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__escrowResendSrvResponse(struct soap *soap, const char *tag, int id, const _WS1__escrowResendSrvResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__escrowResendSrvResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:escrowResendSrvReturn");
	if (soap_out_std__string(soap, "WS1:escrowResendSrvReturn", -1, &a->_WS1__escrowResendSrvResponse::escrowResendSrvReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__escrowResendSrvResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__escrowResendSrvResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__escrowResendSrvResponse * SOAP_FMAC4 soap_in__WS1__escrowResendSrvResponse(struct soap *soap, const char *tag, _WS1__escrowResendSrvResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__escrowResendSrvResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__escrowResendSrvResponse, sizeof(_WS1__escrowResendSrvResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__escrowResendSrvResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__escrowResendSrvResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_escrowResendSrvReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_escrowResendSrvReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:escrowResendSrvReturn", &a->_WS1__escrowResendSrvResponse::escrowResendSrvReturn, "xsd:string"))
				{	soap_flag_escrowResendSrvReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:escrowResendSrvReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_escrowResendSrvReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__escrowResendSrvResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__escrowResendSrvResponse, SOAP_TYPE__WS1__escrowResendSrvResponse, sizeof(_WS1__escrowResendSrvResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__escrowResendSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__escrowResendSrvResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__escrowResendSrvResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__escrowResendSrvResponse *p;
	size_t k = sizeof(_WS1__escrowResendSrvResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__escrowResendSrvResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__escrowResendSrvResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__escrowResendSrvResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__escrowResendSrvResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__escrowResendSrvResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__escrowResendSrvResponse(soap, tag ? tag : "WS1:escrowResendSrvResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__escrowResendSrvResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__escrowResendSrvResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__escrowResendSrvResponse * SOAP_FMAC4 soap_get__WS1__escrowResendSrvResponse(struct soap *soap, _WS1__escrowResendSrvResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__escrowResendSrvResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__escrowResendSrv::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__escrowResendSrv::in0);
	soap_default_std__string(soap, &this->_WS1__escrowResendSrv::in1);
}

void _WS1__escrowResendSrv::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__escrowResendSrv::in0);
	soap_serialize_std__string(soap, &this->_WS1__escrowResendSrv::in1);
#endif
}

int _WS1__escrowResendSrv::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__escrowResendSrv(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__escrowResendSrv(struct soap *soap, const char *tag, int id, const _WS1__escrowResendSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__escrowResendSrv), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__escrowResendSrv::in0, ""))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in1", -1, &a->_WS1__escrowResendSrv::in1, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__escrowResendSrv::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__escrowResendSrv(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__escrowResendSrv * SOAP_FMAC4 soap_in__WS1__escrowResendSrv(struct soap *soap, const char *tag, _WS1__escrowResendSrv *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__escrowResendSrv*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__escrowResendSrv, sizeof(_WS1__escrowResendSrv), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__escrowResendSrv)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__escrowResendSrv *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	size_t soap_flag_in11 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__escrowResendSrv::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap_flag_in11 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in1", &a->_WS1__escrowResendSrv::in1, "xsd:string"))
				{	soap_flag_in11--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0 || soap_flag_in11 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__escrowResendSrv *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__escrowResendSrv, SOAP_TYPE__WS1__escrowResendSrv, sizeof(_WS1__escrowResendSrv), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__escrowResendSrv * SOAP_FMAC2 cross_instantiate__WS1__escrowResendSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__escrowResendSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__escrowResendSrv *p;
	size_t k = sizeof(_WS1__escrowResendSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__escrowResendSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__escrowResendSrv);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__escrowResendSrv, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__escrowResendSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__escrowResendSrv::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__escrowResendSrv(soap, tag ? tag : "WS1:escrowResendSrv", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__escrowResendSrv::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__escrowResendSrv(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__escrowResendSrv * SOAP_FMAC4 soap_get__WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__escrowResendSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeSrvResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeSrvResponse::invokeSrvReturn);
}

void _WS1__invokeSrvResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeSrvResponse::invokeSrvReturn);
#endif
}

int _WS1__invokeSrvResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeSrvResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeSrvResponse(struct soap *soap, const char *tag, int id, const _WS1__invokeSrvResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeSrvResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:invokeSrvReturn");
	if (soap_out_std__string(soap, "WS1:invokeSrvReturn", -1, &a->_WS1__invokeSrvResponse::invokeSrvReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeSrvResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeSrvResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeSrvResponse * SOAP_FMAC4 soap_in__WS1__invokeSrvResponse(struct soap *soap, const char *tag, _WS1__invokeSrvResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeSrvResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeSrvResponse, sizeof(_WS1__invokeSrvResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeSrvResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeSrvResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_invokeSrvReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_invokeSrvReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:invokeSrvReturn", &a->_WS1__invokeSrvResponse::invokeSrvReturn, "xsd:string"))
				{	soap_flag_invokeSrvReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:invokeSrvReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_invokeSrvReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeSrvResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeSrvResponse, SOAP_TYPE__WS1__invokeSrvResponse, sizeof(_WS1__invokeSrvResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeSrvResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeSrvResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeSrvResponse *p;
	size_t k = sizeof(_WS1__invokeSrvResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeSrvResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeSrvResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeSrvResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeSrvResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeSrvResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeSrvResponse(soap, tag ? tag : "WS1:invokeSrvResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeSrvResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeSrvResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeSrvResponse * SOAP_FMAC4 soap_get__WS1__invokeSrvResponse(struct soap *soap, _WS1__invokeSrvResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeSrvResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeSrv::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeSrv::in0);
}

void _WS1__invokeSrv::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeSrv::in0);
#endif
}

int _WS1__invokeSrv::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeSrv(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeSrv(struct soap *soap, const char *tag, int id, const _WS1__invokeSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeSrv), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__invokeSrv::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeSrv::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeSrv(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeSrv * SOAP_FMAC4 soap_in__WS1__invokeSrv(struct soap *soap, const char *tag, _WS1__invokeSrv *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeSrv*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeSrv, sizeof(_WS1__invokeSrv), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeSrv)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeSrv *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__invokeSrv::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeSrv *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeSrv, SOAP_TYPE__WS1__invokeSrv, sizeof(_WS1__invokeSrv), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeSrv * SOAP_FMAC2 cross_instantiate__WS1__invokeSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeSrv *p;
	size_t k = sizeof(_WS1__invokeSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeSrv);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeSrv, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeSrv::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeSrv(soap, tag ? tag : "WS1:invokeSrv", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeSrv::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeSrv(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeSrv * SOAP_FMAC4 soap_get__WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regEAIResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regEAIResponse::regEAIReturn);
}

void _WS1__regEAIResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regEAIResponse::regEAIReturn);
#endif
}

int _WS1__regEAIResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regEAIResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regEAIResponse(struct soap *soap, const char *tag, int id, const _WS1__regEAIResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regEAIResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:regEAIReturn");
	if (soap_out_std__string(soap, "WS1:regEAIReturn", -1, &a->_WS1__regEAIResponse::regEAIReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regEAIResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regEAIResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regEAIResponse * SOAP_FMAC4 soap_in__WS1__regEAIResponse(struct soap *soap, const char *tag, _WS1__regEAIResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regEAIResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regEAIResponse, sizeof(_WS1__regEAIResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regEAIResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regEAIResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_regEAIReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_regEAIReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:regEAIReturn", &a->_WS1__regEAIResponse::regEAIReturn, "xsd:string"))
				{	soap_flag_regEAIReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:regEAIReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_regEAIReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regEAIResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regEAIResponse, SOAP_TYPE__WS1__regEAIResponse, sizeof(_WS1__regEAIResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regEAIResponse * SOAP_FMAC2 cross_instantiate__WS1__regEAIResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regEAIResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regEAIResponse *p;
	size_t k = sizeof(_WS1__regEAIResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regEAIResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regEAIResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regEAIResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regEAIResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regEAIResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regEAIResponse(soap, tag ? tag : "WS1:regEAIResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regEAIResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regEAIResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regEAIResponse * SOAP_FMAC4 soap_get__WS1__regEAIResponse(struct soap *soap, _WS1__regEAIResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regEAIResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regEAI::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regEAI::in0);
}

void _WS1__regEAI::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regEAI::in0);
#endif
}

int _WS1__regEAI::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regEAI(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regEAI(struct soap *soap, const char *tag, int id, const _WS1__regEAI *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regEAI), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__regEAI::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regEAI::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regEAI(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regEAI * SOAP_FMAC4 soap_in__WS1__regEAI(struct soap *soap, const char *tag, _WS1__regEAI *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regEAI*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regEAI, sizeof(_WS1__regEAI), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regEAI)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regEAI *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__regEAI::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regEAI *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regEAI, SOAP_TYPE__WS1__regEAI, sizeof(_WS1__regEAI), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regEAI * SOAP_FMAC2 cross_instantiate__WS1__regEAI(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regEAI(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regEAI *p;
	size_t k = sizeof(_WS1__regEAI);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regEAI, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regEAI);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regEAI, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regEAI location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regEAI::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regEAI(soap, tag ? tag : "WS1:regEAI", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regEAI::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regEAI(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regEAI * SOAP_FMAC4 soap_get__WS1__regEAI(struct soap *soap, _WS1__regEAI *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regEAI(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regSrvResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regSrvResponse::regSrvReturn);
}

void _WS1__regSrvResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regSrvResponse::regSrvReturn);
#endif
}

int _WS1__regSrvResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regSrvResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regSrvResponse(struct soap *soap, const char *tag, int id, const _WS1__regSrvResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regSrvResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:regSrvReturn");
	if (soap_out_std__string(soap, "WS1:regSrvReturn", -1, &a->_WS1__regSrvResponse::regSrvReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regSrvResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regSrvResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regSrvResponse * SOAP_FMAC4 soap_in__WS1__regSrvResponse(struct soap *soap, const char *tag, _WS1__regSrvResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regSrvResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regSrvResponse, sizeof(_WS1__regSrvResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regSrvResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regSrvResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_regSrvReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_regSrvReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:regSrvReturn", &a->_WS1__regSrvResponse::regSrvReturn, "xsd:string"))
				{	soap_flag_regSrvReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:regSrvReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_regSrvReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regSrvResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regSrvResponse, SOAP_TYPE__WS1__regSrvResponse, sizeof(_WS1__regSrvResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__regSrvResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regSrvResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regSrvResponse *p;
	size_t k = sizeof(_WS1__regSrvResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regSrvResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regSrvResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regSrvResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regSrvResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regSrvResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regSrvResponse(soap, tag ? tag : "WS1:regSrvResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regSrvResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regSrvResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regSrvResponse * SOAP_FMAC4 soap_get__WS1__regSrvResponse(struct soap *soap, _WS1__regSrvResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regSrvResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regSrv::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regSrv::in0);
}

void _WS1__regSrv::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regSrv::in0);
#endif
}

int _WS1__regSrv::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regSrv(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regSrv(struct soap *soap, const char *tag, int id, const _WS1__regSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regSrv), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__regSrv::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regSrv::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regSrv(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regSrv * SOAP_FMAC4 soap_in__WS1__regSrv(struct soap *soap, const char *tag, _WS1__regSrv *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regSrv*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regSrv, sizeof(_WS1__regSrv), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regSrv)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regSrv *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__regSrv::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regSrv *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regSrv, SOAP_TYPE__WS1__regSrv, sizeof(_WS1__regSrv), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regSrv * SOAP_FMAC2 cross_instantiate__WS1__regSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regSrv *p;
	size_t k = sizeof(_WS1__regSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regSrv);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regSrv, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regSrv::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regSrv(soap, tag ? tag : "WS1:regSrv", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regSrv::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regSrv(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regSrv * SOAP_FMAC4 soap_get__WS1__regSrv(struct soap *soap, _WS1__regSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getStandardDataNameListResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn);
}

void _WS1__getStandardDataNameListResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn);
#endif
}

int _WS1__getStandardDataNameListResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getStandardDataNameListResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardDataNameListResponse(struct soap *soap, const char *tag, int id, const _WS1__getStandardDataNameListResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getStandardDataNameListResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getStandardDataNameListReturn");
	if (soap_out_std__string(soap, "WS1:getStandardDataNameListReturn", -1, &a->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getStandardDataNameListResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getStandardDataNameListResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getStandardDataNameListResponse * SOAP_FMAC4 soap_in__WS1__getStandardDataNameListResponse(struct soap *soap, const char *tag, _WS1__getStandardDataNameListResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getStandardDataNameListResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getStandardDataNameListResponse, sizeof(_WS1__getStandardDataNameListResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getStandardDataNameListResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getStandardDataNameListResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getStandardDataNameListReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getStandardDataNameListReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getStandardDataNameListReturn", &a->_WS1__getStandardDataNameListResponse::getStandardDataNameListReturn, "xsd:string"))
				{	soap_flag_getStandardDataNameListReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getStandardDataNameListReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getStandardDataNameListReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getStandardDataNameListResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getStandardDataNameListResponse, SOAP_TYPE__WS1__getStandardDataNameListResponse, sizeof(_WS1__getStandardDataNameListResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getStandardDataNameListResponse * SOAP_FMAC2 cross_instantiate__WS1__getStandardDataNameListResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getStandardDataNameListResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getStandardDataNameListResponse *p;
	size_t k = sizeof(_WS1__getStandardDataNameListResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getStandardDataNameListResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getStandardDataNameListResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getStandardDataNameListResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getStandardDataNameListResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getStandardDataNameListResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getStandardDataNameListResponse(soap, tag ? tag : "WS1:getStandardDataNameListResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getStandardDataNameListResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getStandardDataNameListResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getStandardDataNameListResponse * SOAP_FMAC4 soap_get__WS1__getStandardDataNameListResponse(struct soap *soap, _WS1__getStandardDataNameListResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getStandardDataNameListResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getStandardDataNameList::soap_default(struct soap *soap)
{
	this->soap = soap;
}

void _WS1__getStandardDataNameList::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

int _WS1__getStandardDataNameList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getStandardDataNameList(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardDataNameList(struct soap *soap, const char *tag, int id, const _WS1__getStandardDataNameList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getStandardDataNameList), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getStandardDataNameList::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getStandardDataNameList(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getStandardDataNameList * SOAP_FMAC4 soap_in__WS1__getStandardDataNameList(struct soap *soap, const char *tag, _WS1__getStandardDataNameList *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getStandardDataNameList*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getStandardDataNameList, sizeof(_WS1__getStandardDataNameList), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getStandardDataNameList)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getStandardDataNameList *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (_WS1__getStandardDataNameList *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getStandardDataNameList, SOAP_TYPE__WS1__getStandardDataNameList, sizeof(_WS1__getStandardDataNameList), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getStandardDataNameList * SOAP_FMAC2 cross_instantiate__WS1__getStandardDataNameList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getStandardDataNameList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getStandardDataNameList *p;
	size_t k = sizeof(_WS1__getStandardDataNameList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getStandardDataNameList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getStandardDataNameList);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getStandardDataNameList, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getStandardDataNameList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getStandardDataNameList::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getStandardDataNameList(soap, tag ? tag : "WS1:getStandardDataNameList", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getStandardDataNameList::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getStandardDataNameList(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getStandardDataNameList * SOAP_FMAC4 soap_get__WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getStandardDataNameList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getStandardServiceListResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getStandardServiceListResponse::getStandardServiceListReturn);
}

void _WS1__getStandardServiceListResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getStandardServiceListResponse::getStandardServiceListReturn);
#endif
}

int _WS1__getStandardServiceListResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getStandardServiceListResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardServiceListResponse(struct soap *soap, const char *tag, int id, const _WS1__getStandardServiceListResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getStandardServiceListResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getStandardServiceListReturn");
	if (soap_out_std__string(soap, "WS1:getStandardServiceListReturn", -1, &a->_WS1__getStandardServiceListResponse::getStandardServiceListReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getStandardServiceListResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getStandardServiceListResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getStandardServiceListResponse * SOAP_FMAC4 soap_in__WS1__getStandardServiceListResponse(struct soap *soap, const char *tag, _WS1__getStandardServiceListResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getStandardServiceListResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getStandardServiceListResponse, sizeof(_WS1__getStandardServiceListResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getStandardServiceListResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getStandardServiceListResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getStandardServiceListReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getStandardServiceListReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getStandardServiceListReturn", &a->_WS1__getStandardServiceListResponse::getStandardServiceListReturn, "xsd:string"))
				{	soap_flag_getStandardServiceListReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getStandardServiceListReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getStandardServiceListReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getStandardServiceListResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getStandardServiceListResponse, SOAP_TYPE__WS1__getStandardServiceListResponse, sizeof(_WS1__getStandardServiceListResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getStandardServiceListResponse * SOAP_FMAC2 cross_instantiate__WS1__getStandardServiceListResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getStandardServiceListResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getStandardServiceListResponse *p;
	size_t k = sizeof(_WS1__getStandardServiceListResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getStandardServiceListResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getStandardServiceListResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getStandardServiceListResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getStandardServiceListResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getStandardServiceListResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getStandardServiceListResponse(soap, tag ? tag : "WS1:getStandardServiceListResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getStandardServiceListResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getStandardServiceListResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getStandardServiceListResponse * SOAP_FMAC4 soap_get__WS1__getStandardServiceListResponse(struct soap *soap, _WS1__getStandardServiceListResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getStandardServiceListResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getStandardServiceList::soap_default(struct soap *soap)
{
	this->soap = soap;
}

void _WS1__getStandardServiceList::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

int _WS1__getStandardServiceList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getStandardServiceList(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getStandardServiceList(struct soap *soap, const char *tag, int id, const _WS1__getStandardServiceList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getStandardServiceList), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getStandardServiceList::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getStandardServiceList(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getStandardServiceList * SOAP_FMAC4 soap_in__WS1__getStandardServiceList(struct soap *soap, const char *tag, _WS1__getStandardServiceList *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getStandardServiceList*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getStandardServiceList, sizeof(_WS1__getStandardServiceList), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getStandardServiceList)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getStandardServiceList *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (_WS1__getStandardServiceList *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getStandardServiceList, SOAP_TYPE__WS1__getStandardServiceList, sizeof(_WS1__getStandardServiceList), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getStandardServiceList * SOAP_FMAC2 cross_instantiate__WS1__getStandardServiceList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getStandardServiceList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getStandardServiceList *p;
	size_t k = sizeof(_WS1__getStandardServiceList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getStandardServiceList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getStandardServiceList);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getStandardServiceList, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getStandardServiceList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getStandardServiceList::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getStandardServiceList(soap, tag ? tag : "WS1:getStandardServiceList", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getStandardServiceList::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getStandardServiceList(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getStandardServiceList * SOAP_FMAC4 soap_get__WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getStandardServiceList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__fpInvokeResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__fpInvokeResponse::fpInvokeReturn);
}

void _WS1__fpInvokeResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__fpInvokeResponse::fpInvokeReturn);
#endif
}

int _WS1__fpInvokeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__fpInvokeResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__fpInvokeResponse(struct soap *soap, const char *tag, int id, const _WS1__fpInvokeResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__fpInvokeResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:fpInvokeReturn");
	if (soap_out_std__string(soap, "WS1:fpInvokeReturn", -1, &a->_WS1__fpInvokeResponse::fpInvokeReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__fpInvokeResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__fpInvokeResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__fpInvokeResponse * SOAP_FMAC4 soap_in__WS1__fpInvokeResponse(struct soap *soap, const char *tag, _WS1__fpInvokeResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__fpInvokeResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__fpInvokeResponse, sizeof(_WS1__fpInvokeResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__fpInvokeResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__fpInvokeResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_fpInvokeReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_fpInvokeReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:fpInvokeReturn", &a->_WS1__fpInvokeResponse::fpInvokeReturn, "xsd:string"))
				{	soap_flag_fpInvokeReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:fpInvokeReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_fpInvokeReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__fpInvokeResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__fpInvokeResponse, SOAP_TYPE__WS1__fpInvokeResponse, sizeof(_WS1__fpInvokeResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__fpInvokeResponse * SOAP_FMAC2 cross_instantiate__WS1__fpInvokeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__fpInvokeResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__fpInvokeResponse *p;
	size_t k = sizeof(_WS1__fpInvokeResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__fpInvokeResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__fpInvokeResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__fpInvokeResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__fpInvokeResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__fpInvokeResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__fpInvokeResponse(soap, tag ? tag : "WS1:fpInvokeResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__fpInvokeResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__fpInvokeResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__fpInvokeResponse * SOAP_FMAC4 soap_get__WS1__fpInvokeResponse(struct soap *soap, _WS1__fpInvokeResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__fpInvokeResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__fpInvoke::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__fpInvoke::in0);
}

void _WS1__fpInvoke::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__fpInvoke::in0);
#endif
}

int _WS1__fpInvoke::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__fpInvoke(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__fpInvoke(struct soap *soap, const char *tag, int id, const _WS1__fpInvoke *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__fpInvoke), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__fpInvoke::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__fpInvoke::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__fpInvoke(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__fpInvoke * SOAP_FMAC4 soap_in__WS1__fpInvoke(struct soap *soap, const char *tag, _WS1__fpInvoke *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__fpInvoke*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__fpInvoke, sizeof(_WS1__fpInvoke), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__fpInvoke)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__fpInvoke *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__fpInvoke::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__fpInvoke *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__fpInvoke, SOAP_TYPE__WS1__fpInvoke, sizeof(_WS1__fpInvoke), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__fpInvoke * SOAP_FMAC2 cross_instantiate__WS1__fpInvoke(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__fpInvoke(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__fpInvoke *p;
	size_t k = sizeof(_WS1__fpInvoke);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__fpInvoke, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__fpInvoke);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__fpInvoke, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__fpInvoke location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__fpInvoke::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__fpInvoke(soap, tag ? tag : "WS1:fpInvoke", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__fpInvoke::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__fpInvoke(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__fpInvoke * SOAP_FMAC4 soap_get__WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__fpInvoke(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getSrvResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getSrvResponse::getSrvReturn);
}

void _WS1__getSrvResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getSrvResponse::getSrvReturn);
#endif
}

int _WS1__getSrvResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getSrvResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getSrvResponse(struct soap *soap, const char *tag, int id, const _WS1__getSrvResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getSrvResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getSrvReturn");
	if (soap_out_std__string(soap, "WS1:getSrvReturn", -1, &a->_WS1__getSrvResponse::getSrvReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getSrvResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getSrvResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getSrvResponse * SOAP_FMAC4 soap_in__WS1__getSrvResponse(struct soap *soap, const char *tag, _WS1__getSrvResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getSrvResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getSrvResponse, sizeof(_WS1__getSrvResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getSrvResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getSrvResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getSrvReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getSrvReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getSrvReturn", &a->_WS1__getSrvResponse::getSrvReturn, "xsd:string"))
				{	soap_flag_getSrvReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getSrvReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getSrvReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getSrvResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getSrvResponse, SOAP_TYPE__WS1__getSrvResponse, sizeof(_WS1__getSrvResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getSrvResponse * SOAP_FMAC2 cross_instantiate__WS1__getSrvResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getSrvResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getSrvResponse *p;
	size_t k = sizeof(_WS1__getSrvResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getSrvResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getSrvResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getSrvResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getSrvResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getSrvResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getSrvResponse(soap, tag ? tag : "WS1:getSrvResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getSrvResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getSrvResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getSrvResponse * SOAP_FMAC4 soap_get__WS1__getSrvResponse(struct soap *soap, _WS1__getSrvResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getSrvResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getSrv::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getSrv::in0);
}

void _WS1__getSrv::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getSrv::in0);
#endif
}

int _WS1__getSrv::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getSrv(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getSrv(struct soap *soap, const char *tag, int id, const _WS1__getSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getSrv), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__getSrv::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getSrv::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getSrv(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getSrv * SOAP_FMAC4 soap_in__WS1__getSrv(struct soap *soap, const char *tag, _WS1__getSrv *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getSrv*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getSrv, sizeof(_WS1__getSrv), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getSrv)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getSrv *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__getSrv::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getSrv *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getSrv, SOAP_TYPE__WS1__getSrv, sizeof(_WS1__getSrv), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getSrv * SOAP_FMAC2 cross_instantiate__WS1__getSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getSrv *p;
	size_t k = sizeof(_WS1__getSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getSrv);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getSrv, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getSrv::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getSrv(soap, tag ? tag : "WS1:getSrv", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getSrv::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getSrv(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getSrv * SOAP_FMAC4 soap_get__WS1__getSrv(struct soap *soap, _WS1__getSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getProdResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getProdResponse::getProdReturn);
}

void _WS1__getProdResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getProdResponse::getProdReturn);
#endif
}

int _WS1__getProdResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getProdResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdResponse(struct soap *soap, const char *tag, int id, const _WS1__getProdResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getProdResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getProdReturn");
	if (soap_out_std__string(soap, "WS1:getProdReturn", -1, &a->_WS1__getProdResponse::getProdReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getProdResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getProdResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getProdResponse * SOAP_FMAC4 soap_in__WS1__getProdResponse(struct soap *soap, const char *tag, _WS1__getProdResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getProdResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getProdResponse, sizeof(_WS1__getProdResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getProdResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getProdResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getProdReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getProdReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getProdReturn", &a->_WS1__getProdResponse::getProdReturn, "xsd:string"))
				{	soap_flag_getProdReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getProdReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getProdReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getProdResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getProdResponse, SOAP_TYPE__WS1__getProdResponse, sizeof(_WS1__getProdResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getProdResponse * SOAP_FMAC2 cross_instantiate__WS1__getProdResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getProdResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getProdResponse *p;
	size_t k = sizeof(_WS1__getProdResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getProdResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getProdResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getProdResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getProdResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getProdResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getProdResponse(soap, tag ? tag : "WS1:getProdResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getProdResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getProdResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getProdResponse * SOAP_FMAC4 soap_get__WS1__getProdResponse(struct soap *soap, _WS1__getProdResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getProdResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getProd::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getProd::in0);
}

void _WS1__getProd::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getProd::in0);
#endif
}

int _WS1__getProd::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getProd(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProd(struct soap *soap, const char *tag, int id, const _WS1__getProd *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getProd), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__getProd::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getProd::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getProd(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getProd * SOAP_FMAC4 soap_in__WS1__getProd(struct soap *soap, const char *tag, _WS1__getProd *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getProd*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getProd, sizeof(_WS1__getProd), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getProd)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getProd *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__getProd::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getProd *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getProd, SOAP_TYPE__WS1__getProd, sizeof(_WS1__getProd), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getProd * SOAP_FMAC2 cross_instantiate__WS1__getProd(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getProd(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getProd *p;
	size_t k = sizeof(_WS1__getProd);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getProd, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getProd);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getProd, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getProd location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getProd::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getProd(soap, tag ? tag : "WS1:getProd", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getProd::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getProd(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getProd * SOAP_FMAC4 soap_get__WS1__getProd(struct soap *soap, _WS1__getProd *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getProd(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeMdmResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeMdmResponse::invokeMdmReturn);
}

void _WS1__invokeMdmResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeMdmResponse::invokeMdmReturn);
#endif
}

int _WS1__invokeMdmResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeMdmResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeMdmResponse(struct soap *soap, const char *tag, int id, const _WS1__invokeMdmResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeMdmResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:invokeMdmReturn");
	if (soap_out_std__string(soap, "WS1:invokeMdmReturn", -1, &a->_WS1__invokeMdmResponse::invokeMdmReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeMdmResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeMdmResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeMdmResponse * SOAP_FMAC4 soap_in__WS1__invokeMdmResponse(struct soap *soap, const char *tag, _WS1__invokeMdmResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeMdmResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeMdmResponse, sizeof(_WS1__invokeMdmResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeMdmResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeMdmResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_invokeMdmReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_invokeMdmReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:invokeMdmReturn", &a->_WS1__invokeMdmResponse::invokeMdmReturn, "xsd:string"))
				{	soap_flag_invokeMdmReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:invokeMdmReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_invokeMdmReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeMdmResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeMdmResponse, SOAP_TYPE__WS1__invokeMdmResponse, sizeof(_WS1__invokeMdmResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeMdmResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeMdmResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeMdmResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeMdmResponse *p;
	size_t k = sizeof(_WS1__invokeMdmResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeMdmResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeMdmResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeMdmResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeMdmResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeMdmResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeMdmResponse(soap, tag ? tag : "WS1:invokeMdmResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeMdmResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeMdmResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeMdmResponse * SOAP_FMAC4 soap_get__WS1__invokeMdmResponse(struct soap *soap, _WS1__invokeMdmResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeMdmResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeMdm::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeMdm::in0);
}

void _WS1__invokeMdm::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeMdm::in0);
#endif
}

int _WS1__invokeMdm::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeMdm(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeMdm(struct soap *soap, const char *tag, int id, const _WS1__invokeMdm *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeMdm), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__invokeMdm::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeMdm::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeMdm(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeMdm * SOAP_FMAC4 soap_in__WS1__invokeMdm(struct soap *soap, const char *tag, _WS1__invokeMdm *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeMdm*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeMdm, sizeof(_WS1__invokeMdm), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeMdm)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeMdm *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__invokeMdm::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeMdm *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeMdm, SOAP_TYPE__WS1__invokeMdm, sizeof(_WS1__invokeMdm), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeMdm * SOAP_FMAC2 cross_instantiate__WS1__invokeMdm(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeMdm(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeMdm *p;
	size_t k = sizeof(_WS1__invokeMdm);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeMdm, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeMdm);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeMdm, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeMdm location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeMdm::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeMdm(soap, tag ? tag : "WS1:invokeMdm", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeMdm::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeMdm(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeMdm * SOAP_FMAC4 soap_get__WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeMdm(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeUnionResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeUnionResponse::invokeUnionReturn);
}

void _WS1__invokeUnionResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeUnionResponse::invokeUnionReturn);
#endif
}

int _WS1__invokeUnionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeUnionResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeUnionResponse(struct soap *soap, const char *tag, int id, const _WS1__invokeUnionResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeUnionResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:invokeUnionReturn");
	if (soap_out_std__string(soap, "WS1:invokeUnionReturn", -1, &a->_WS1__invokeUnionResponse::invokeUnionReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeUnionResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeUnionResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeUnionResponse * SOAP_FMAC4 soap_in__WS1__invokeUnionResponse(struct soap *soap, const char *tag, _WS1__invokeUnionResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeUnionResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeUnionResponse, sizeof(_WS1__invokeUnionResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeUnionResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeUnionResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_invokeUnionReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_invokeUnionReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:invokeUnionReturn", &a->_WS1__invokeUnionResponse::invokeUnionReturn, "xsd:string"))
				{	soap_flag_invokeUnionReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:invokeUnionReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_invokeUnionReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeUnionResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeUnionResponse, SOAP_TYPE__WS1__invokeUnionResponse, sizeof(_WS1__invokeUnionResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeUnionResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeUnionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeUnionResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeUnionResponse *p;
	size_t k = sizeof(_WS1__invokeUnionResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeUnionResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeUnionResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeUnionResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeUnionResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeUnionResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeUnionResponse(soap, tag ? tag : "WS1:invokeUnionResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeUnionResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeUnionResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeUnionResponse * SOAP_FMAC4 soap_get__WS1__invokeUnionResponse(struct soap *soap, _WS1__invokeUnionResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeUnionResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeUnion::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeUnion::in0);
	soap_default_std__string(soap, &this->_WS1__invokeUnion::in1);
}

void _WS1__invokeUnion::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeUnion::in0);
	soap_serialize_std__string(soap, &this->_WS1__invokeUnion::in1);
#endif
}

int _WS1__invokeUnion::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeUnion(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeUnion(struct soap *soap, const char *tag, int id, const _WS1__invokeUnion *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeUnion), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__invokeUnion::in0, ""))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in1", -1, &a->_WS1__invokeUnion::in1, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeUnion::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeUnion(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeUnion * SOAP_FMAC4 soap_in__WS1__invokeUnion(struct soap *soap, const char *tag, _WS1__invokeUnion *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeUnion*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeUnion, sizeof(_WS1__invokeUnion), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeUnion)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeUnion *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	size_t soap_flag_in11 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__invokeUnion::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap_flag_in11 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in1", &a->_WS1__invokeUnion::in1, "xsd:string"))
				{	soap_flag_in11--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0 || soap_flag_in11 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeUnion *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeUnion, SOAP_TYPE__WS1__invokeUnion, sizeof(_WS1__invokeUnion), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeUnion * SOAP_FMAC2 cross_instantiate__WS1__invokeUnion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeUnion(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeUnion *p;
	size_t k = sizeof(_WS1__invokeUnion);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeUnion, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeUnion);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeUnion, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeUnion location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeUnion::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeUnion(soap, tag ? tag : "WS1:invokeUnion", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeUnion::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeUnion(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeUnion * SOAP_FMAC4 soap_get__WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeUnion(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regProdAPResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regProdAPResponse::regProdAPReturn);
}

void _WS1__regProdAPResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regProdAPResponse::regProdAPReturn);
#endif
}

int _WS1__regProdAPResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regProdAPResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regProdAPResponse(struct soap *soap, const char *tag, int id, const _WS1__regProdAPResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regProdAPResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:regProdAPReturn");
	if (soap_out_std__string(soap, "WS1:regProdAPReturn", -1, &a->_WS1__regProdAPResponse::regProdAPReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regProdAPResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regProdAPResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regProdAPResponse * SOAP_FMAC4 soap_in__WS1__regProdAPResponse(struct soap *soap, const char *tag, _WS1__regProdAPResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regProdAPResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regProdAPResponse, sizeof(_WS1__regProdAPResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regProdAPResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regProdAPResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_regProdAPReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_regProdAPReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:regProdAPReturn", &a->_WS1__regProdAPResponse::regProdAPReturn, "xsd:string"))
				{	soap_flag_regProdAPReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:regProdAPReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_regProdAPReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regProdAPResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regProdAPResponse, SOAP_TYPE__WS1__regProdAPResponse, sizeof(_WS1__regProdAPResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regProdAPResponse * SOAP_FMAC2 cross_instantiate__WS1__regProdAPResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regProdAPResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regProdAPResponse *p;
	size_t k = sizeof(_WS1__regProdAPResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regProdAPResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regProdAPResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regProdAPResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regProdAPResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regProdAPResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regProdAPResponse(soap, tag ? tag : "WS1:regProdAPResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regProdAPResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regProdAPResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regProdAPResponse * SOAP_FMAC4 soap_get__WS1__regProdAPResponse(struct soap *soap, _WS1__regProdAPResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regProdAPResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__regProdAP::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__regProdAP::in0);
}

void _WS1__regProdAP::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__regProdAP::in0);
#endif
}

int _WS1__regProdAP::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__regProdAP(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__regProdAP(struct soap *soap, const char *tag, int id, const _WS1__regProdAP *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__regProdAP), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__regProdAP::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__regProdAP::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__regProdAP(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__regProdAP * SOAP_FMAC4 soap_in__WS1__regProdAP(struct soap *soap, const char *tag, _WS1__regProdAP *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__regProdAP*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__regProdAP, sizeof(_WS1__regProdAP), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__regProdAP)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__regProdAP *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__regProdAP::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__regProdAP *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__regProdAP, SOAP_TYPE__WS1__regProdAP, sizeof(_WS1__regProdAP), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__regProdAP * SOAP_FMAC2 cross_instantiate__WS1__regProdAP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__regProdAP(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__regProdAP *p;
	size_t k = sizeof(_WS1__regProdAP);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__regProdAP, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__regProdAP);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__regProdAP, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__regProdAP location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__regProdAP::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__regProdAP(soap, tag ? tag : "WS1:regProdAP", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__regProdAP::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__regProdAP(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__regProdAP * SOAP_FMAC4 soap_get__WS1__regProdAP(struct soap *soap, _WS1__regProdAP *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__regProdAP(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getProdListResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getProdListResponse::getProdListReturn);
}

void _WS1__getProdListResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getProdListResponse::getProdListReturn);
#endif
}

int _WS1__getProdListResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getProdListResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdListResponse(struct soap *soap, const char *tag, int id, const _WS1__getProdListResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getProdListResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getProdListReturn");
	if (soap_out_std__string(soap, "WS1:getProdListReturn", -1, &a->_WS1__getProdListResponse::getProdListReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getProdListResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getProdListResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getProdListResponse * SOAP_FMAC4 soap_in__WS1__getProdListResponse(struct soap *soap, const char *tag, _WS1__getProdListResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getProdListResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getProdListResponse, sizeof(_WS1__getProdListResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getProdListResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getProdListResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getProdListReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getProdListReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getProdListReturn", &a->_WS1__getProdListResponse::getProdListReturn, "xsd:string"))
				{	soap_flag_getProdListReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getProdListReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getProdListReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getProdListResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getProdListResponse, SOAP_TYPE__WS1__getProdListResponse, sizeof(_WS1__getProdListResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getProdListResponse * SOAP_FMAC2 cross_instantiate__WS1__getProdListResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getProdListResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getProdListResponse *p;
	size_t k = sizeof(_WS1__getProdListResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getProdListResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getProdListResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getProdListResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getProdListResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getProdListResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getProdListResponse(soap, tag ? tag : "WS1:getProdListResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getProdListResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getProdListResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getProdListResponse * SOAP_FMAC4 soap_get__WS1__getProdListResponse(struct soap *soap, _WS1__getProdListResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getProdListResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getProdList::soap_default(struct soap *soap)
{
	this->soap = soap;
}

void _WS1__getProdList::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

int _WS1__getProdList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getProdList(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getProdList(struct soap *soap, const char *tag, int id, const _WS1__getProdList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getProdList), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getProdList::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getProdList(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getProdList * SOAP_FMAC4 soap_in__WS1__getProdList(struct soap *soap, const char *tag, _WS1__getProdList *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getProdList*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getProdList, sizeof(_WS1__getProdList), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getProdList)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getProdList *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (_WS1__getProdList *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getProdList, SOAP_TYPE__WS1__getProdList, sizeof(_WS1__getProdList), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getProdList * SOAP_FMAC2 cross_instantiate__WS1__getProdList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getProdList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getProdList *p;
	size_t k = sizeof(_WS1__getProdList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getProdList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getProdList);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getProdList, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getProdList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getProdList::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getProdList(soap, tag ? tag : "WS1:getProdList", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getProdList::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getProdList(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getProdList * SOAP_FMAC4 soap_get__WS1__getProdList(struct soap *soap, _WS1__getProdList *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getProdList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getParamListResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getParamListResponse::getParamListReturn);
}

void _WS1__getParamListResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getParamListResponse::getParamListReturn);
#endif
}

int _WS1__getParamListResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getParamListResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getParamListResponse(struct soap *soap, const char *tag, int id, const _WS1__getParamListResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getParamListResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getParamListReturn");
	if (soap_out_std__string(soap, "WS1:getParamListReturn", -1, &a->_WS1__getParamListResponse::getParamListReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getParamListResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getParamListResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getParamListResponse * SOAP_FMAC4 soap_in__WS1__getParamListResponse(struct soap *soap, const char *tag, _WS1__getParamListResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getParamListResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getParamListResponse, sizeof(_WS1__getParamListResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getParamListResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getParamListResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getParamListReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getParamListReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getParamListReturn", &a->_WS1__getParamListResponse::getParamListReturn, "xsd:string"))
				{	soap_flag_getParamListReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getParamListReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getParamListReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getParamListResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getParamListResponse, SOAP_TYPE__WS1__getParamListResponse, sizeof(_WS1__getParamListResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getParamListResponse * SOAP_FMAC2 cross_instantiate__WS1__getParamListResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getParamListResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getParamListResponse *p;
	size_t k = sizeof(_WS1__getParamListResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getParamListResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getParamListResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getParamListResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getParamListResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getParamListResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getParamListResponse(soap, tag ? tag : "WS1:getParamListResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getParamListResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getParamListResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getParamListResponse * SOAP_FMAC4 soap_get__WS1__getParamListResponse(struct soap *soap, _WS1__getParamListResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getParamListResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getParamList::soap_default(struct soap *soap)
{
	this->soap = soap;
}

void _WS1__getParamList::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

int _WS1__getParamList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getParamList(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getParamList(struct soap *soap, const char *tag, int id, const _WS1__getParamList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getParamList), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getParamList::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getParamList(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getParamList * SOAP_FMAC4 soap_in__WS1__getParamList(struct soap *soap, const char *tag, _WS1__getParamList *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getParamList*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getParamList, sizeof(_WS1__getParamList), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getParamList)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getParamList *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (_WS1__getParamList *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getParamList, SOAP_TYPE__WS1__getParamList, sizeof(_WS1__getParamList), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getParamList * SOAP_FMAC2 cross_instantiate__WS1__getParamList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getParamList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getParamList *p;
	size_t k = sizeof(_WS1__getParamList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getParamList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getParamList);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getParamList, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getParamList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getParamList::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getParamList(soap, tag ? tag : "WS1:getParamList", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getParamList::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getParamList(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getParamList * SOAP_FMAC4 soap_get__WS1__getParamList(struct soap *soap, _WS1__getParamList *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getParamList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getEtlJobListResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getEtlJobListResponse::getEtlJobListReturn);
}

void _WS1__getEtlJobListResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getEtlJobListResponse::getEtlJobListReturn);
#endif
}

int _WS1__getEtlJobListResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getEtlJobListResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getEtlJobListResponse(struct soap *soap, const char *tag, int id, const _WS1__getEtlJobListResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getEtlJobListResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:getEtlJobListReturn");
	if (soap_out_std__string(soap, "WS1:getEtlJobListReturn", -1, &a->_WS1__getEtlJobListResponse::getEtlJobListReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getEtlJobListResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getEtlJobListResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getEtlJobListResponse * SOAP_FMAC4 soap_in__WS1__getEtlJobListResponse(struct soap *soap, const char *tag, _WS1__getEtlJobListResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getEtlJobListResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getEtlJobListResponse, sizeof(_WS1__getEtlJobListResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getEtlJobListResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getEtlJobListResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_getEtlJobListReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_getEtlJobListReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:getEtlJobListReturn", &a->_WS1__getEtlJobListResponse::getEtlJobListReturn, "xsd:string"))
				{	soap_flag_getEtlJobListReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:getEtlJobListReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_getEtlJobListReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getEtlJobListResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getEtlJobListResponse, SOAP_TYPE__WS1__getEtlJobListResponse, sizeof(_WS1__getEtlJobListResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getEtlJobListResponse * SOAP_FMAC2 cross_instantiate__WS1__getEtlJobListResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getEtlJobListResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getEtlJobListResponse *p;
	size_t k = sizeof(_WS1__getEtlJobListResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getEtlJobListResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getEtlJobListResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getEtlJobListResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getEtlJobListResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getEtlJobListResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getEtlJobListResponse(soap, tag ? tag : "WS1:getEtlJobListResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getEtlJobListResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getEtlJobListResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getEtlJobListResponse * SOAP_FMAC4 soap_get__WS1__getEtlJobListResponse(struct soap *soap, _WS1__getEtlJobListResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getEtlJobListResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__getEtlJobList::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__getEtlJobList::in0);
}

void _WS1__getEtlJobList::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__getEtlJobList::in0);
#endif
}

int _WS1__getEtlJobList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__getEtlJobList(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__getEtlJobList(struct soap *soap, const char *tag, int id, const _WS1__getEtlJobList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__getEtlJobList), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__getEtlJobList::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__getEtlJobList::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__getEtlJobList(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__getEtlJobList * SOAP_FMAC4 soap_in__WS1__getEtlJobList(struct soap *soap, const char *tag, _WS1__getEtlJobList *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__getEtlJobList*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__getEtlJobList, sizeof(_WS1__getEtlJobList), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__getEtlJobList)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__getEtlJobList *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__getEtlJobList::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__getEtlJobList *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__getEtlJobList, SOAP_TYPE__WS1__getEtlJobList, sizeof(_WS1__getEtlJobList), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__getEtlJobList * SOAP_FMAC2 cross_instantiate__WS1__getEtlJobList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__getEtlJobList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__getEtlJobList *p;
	size_t k = sizeof(_WS1__getEtlJobList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__getEtlJobList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__getEtlJobList);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__getEtlJobList, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__getEtlJobList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__getEtlJobList::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__getEtlJobList(soap, tag ? tag : "WS1:getEtlJobList", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__getEtlJobList::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__getEtlJobList(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__getEtlJobList * SOAP_FMAC4 soap_get__WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__getEtlJobList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeEtlResponse::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeEtlResponse::invokeEtlReturn);
}

void _WS1__invokeEtlResponse::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeEtlResponse::invokeEtlReturn);
#endif
}

int _WS1__invokeEtlResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeEtlResponse(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeEtlResponse(struct soap *soap, const char *tag, int id, const _WS1__invokeEtlResponse *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeEtlResponse), type))
		return soap->error;
	soap_element_result(soap, "WS1:invokeEtlReturn");
	if (soap_out_std__string(soap, "WS1:invokeEtlReturn", -1, &a->_WS1__invokeEtlResponse::invokeEtlReturn, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeEtlResponse::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeEtlResponse(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeEtlResponse * SOAP_FMAC4 soap_in__WS1__invokeEtlResponse(struct soap *soap, const char *tag, _WS1__invokeEtlResponse *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeEtlResponse*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeEtlResponse, sizeof(_WS1__invokeEtlResponse), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeEtlResponse)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeEtlResponse *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_invokeEtlReturn1 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_invokeEtlReturn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:invokeEtlReturn", &a->_WS1__invokeEtlResponse::invokeEtlReturn, "xsd:string"))
				{	soap_flag_invokeEtlReturn1--;
					continue;
				}
			}
			soap_check_result(soap, "WS1:invokeEtlReturn");
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_invokeEtlReturn1 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeEtlResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeEtlResponse, SOAP_TYPE__WS1__invokeEtlResponse, sizeof(_WS1__invokeEtlResponse), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeEtlResponse * SOAP_FMAC2 cross_instantiate__WS1__invokeEtlResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeEtlResponse(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeEtlResponse *p;
	size_t k = sizeof(_WS1__invokeEtlResponse);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeEtlResponse, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeEtlResponse);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeEtlResponse, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeEtlResponse location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeEtlResponse::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeEtlResponse(soap, tag ? tag : "WS1:invokeEtlResponse", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeEtlResponse::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeEtlResponse(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeEtlResponse * SOAP_FMAC4 soap_get__WS1__invokeEtlResponse(struct soap *soap, _WS1__invokeEtlResponse *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeEtlResponse(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void _WS1__invokeEtl::soap_default(struct soap *soap)
{
	this->soap = soap;
	soap_default_std__string(soap, &this->_WS1__invokeEtl::in0);
}

void _WS1__invokeEtl::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_std__string(soap, &this->_WS1__invokeEtl::in0);
#endif
}

int _WS1__invokeEtl::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
{
	return soap_out__WS1__invokeEtl(soap, tag, id, this, type);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__WS1__invokeEtl(struct soap *soap, const char *tag, int id, const _WS1__invokeEtl *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__WS1__invokeEtl), type))
		return soap->error;
	if (soap_out_std__string(soap, "WS1:in0", -1, &a->_WS1__invokeEtl::in0, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

void *_WS1__invokeEtl::soap_in(struct soap *soap, const char *tag, const char *type)
{
	return soap_in__WS1__invokeEtl(soap, tag, this, type);
}

SOAP_FMAC3 _WS1__invokeEtl * SOAP_FMAC4 soap_in__WS1__invokeEtl(struct soap *soap, const char *tag, _WS1__invokeEtl *a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (_WS1__invokeEtl*)soap_id_enter(soap, soap->id, a, SOAP_TYPE__WS1__invokeEtl, sizeof(_WS1__invokeEtl), soap->type, soap->arrayType, cross_instantiate, cross_fbase);
	if (!a)
		return NULL;
	if (soap->alloced && soap->alloced != SOAP_TYPE__WS1__invokeEtl)
	{	soap_revert(soap);
		*soap->id = '\0';
		return (_WS1__invokeEtl *)a->soap_in(soap, tag, type);
	}
	if (soap->alloced)
		a->soap_default(soap);
	size_t soap_flag_in01 = 1;
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_in01 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_std__string(soap, "WS1:in0", &a->_WS1__invokeEtl::in0, "xsd:string"))
				{	soap_flag_in01--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
		if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_in01 > 0))
		{	soap->error = SOAP_OCCURS;
			return NULL;
		}
	}
	else if ((soap->mode & SOAP_XML_STRICT) && *soap->href != '#')
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	else
	{	a = (_WS1__invokeEtl *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE__WS1__invokeEtl, SOAP_TYPE__WS1__invokeEtl, sizeof(_WS1__invokeEtl), 0, cross_finsert, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 _WS1__invokeEtl * SOAP_FMAC2 cross_instantiate__WS1__invokeEtl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate__WS1__invokeEtl(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	_WS1__invokeEtl *p;
	size_t k = sizeof(_WS1__invokeEtl);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE__WS1__invokeEtl, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, _WS1__invokeEtl);
		if (p)
			p->soap = soap;
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, _WS1__invokeEtl, n);
		k *= n;
		if (p)
			for (int i = 0; i < n; i++)
				p[i].soap = soap;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _WS1__invokeEtl location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

int _WS1__invokeEtl::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	if (soap_out__WS1__invokeEtl(soap, tag ? tag : "WS1:invokeEtl", -2, this, type))
		return soap->error;
	return soap_putindependent(soap);
}

void *_WS1__invokeEtl::soap_get(struct soap *soap, const char *tag, const char *type)
{
	return soap_get__WS1__invokeEtl(soap, this, tag, type);
}

SOAP_FMAC3 _WS1__invokeEtl * SOAP_FMAC4 soap_get__WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl *p, const char *tag, const char *type)
{
	if ((p = soap_in__WS1__invokeEtl(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default__QName(soap, &a->faultcode);
	soap_default_string(soap, &a->faultstring);
	soap_default_string(soap, &a->faultactor);
	a->detail = NULL;
	a->SOAP_ENV__Code = NULL;
	a->SOAP_ENV__Reason = NULL;
	soap_default_string(soap, &a->SOAP_ENV__Node);
	soap_default_string(soap, &a->SOAP_ENV__Role);
	a->SOAP_ENV__Detail = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize__QName(soap, (char*const*)&a->faultcode);
	soap_serialize_string(soap, (char*const*)&a->faultstring);
	soap_serialize_string(soap, (char*const*)&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, (char*const*)&a->SOAP_ENV__Node);
	soap_serialize_string(soap, (char*const*)&a->SOAP_ENV__Role);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Fault *a, const char *type)
{
	const char *soap_tmp_faultcode;
	soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
		return soap->error;
	if (soap_out__QName(soap, "faultcode", -1, (char*const*)(void*)&soap_tmp_faultcode, ""))
		return soap->error;
	if (soap_out_string(soap, "faultstring", -1, (char*const*)&a->faultstring, ""))
		return soap->error;
	if (soap_out_string(soap, "faultactor", -1, (char*const*)&a->faultactor, ""))
		return soap->error;
	if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
		return soap->error;
	if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
		return soap->error;
	if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
		return soap->error;
	if (soap_out_string(soap, "SOAP-ENV:Node", -1, (char*const*)&a->SOAP_ENV__Node, ""))
		return soap->error;
	if (soap_out_string(soap, "SOAP-ENV:Role", -1, (char*const*)&a->SOAP_ENV__Role, ""))
		return soap->error;
	if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap *soap, const char *tag, struct SOAP_ENV__Fault *a, const char *type)
{
	size_t soap_flag_faultcode = 1;
	size_t soap_flag_faultstring = 1;
	size_t soap_flag_faultactor = 1;
	size_t soap_flag_detail = 1;
	size_t soap_flag_SOAP_ENV__Code = 1;
	size_t soap_flag_SOAP_ENV__Reason = 1;
	size_t soap_flag_SOAP_ENV__Node = 1;
	size_t soap_flag_SOAP_ENV__Role = 1;
	size_t soap_flag_SOAP_ENV__Detail = 1;
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	(void)type; /* appease -Wall -Werror */
	a = (struct SOAP_ENV__Fault*)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_SOAP_ENV__Fault(soap, a);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in__QName(soap, "faultcode", (char**)&a->faultcode, "xsd:QName"))
				{	soap_flag_faultcode--;
					continue;
				}
			}
			if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_string(soap, "faultstring", (char**)&a->faultstring, "xsd:string"))
				{	soap_flag_faultstring--;
					continue;
				}
			}
			if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_string(soap, "faultactor", (char**)&a->faultactor, "xsd:string"))
				{	soap_flag_faultactor--;
					continue;
				}
			}
			if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
				{	soap_flag_detail--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
				{	soap_flag_SOAP_ENV__Code--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
				{	soap_flag_SOAP_ENV__Reason--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_string(soap, "SOAP-ENV:Node", (char**)&a->SOAP_ENV__Node, "xsd:string"))
				{	soap_flag_SOAP_ENV__Node--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_string(soap, "SOAP-ENV:Role", (char**)&a->SOAP_ENV__Role, "xsd:string"))
				{	soap_flag_SOAP_ENV__Role--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
				{	soap_flag_SOAP_ENV__Detail--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Fault, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, cross_finsert, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 cross_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_SOAP_ENV__Fault(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct SOAP_ENV__Fault *p;
	size_t k = sizeof(struct SOAP_ENV__Fault);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_SOAP_ENV__Fault, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct SOAP_ENV__Fault);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct SOAP_ENV__Fault, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct SOAP_ENV__Fault location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a, const char *tag, const char *type)
{
	if (soap_out_SOAP_ENV__Fault(soap, tag ? tag : "SOAP-ENV:Fault", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p, const char *tag, const char *type)
{
	if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_string(soap, &a->SOAP_ENV__Text);
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_string(soap, (char*const*)&a->SOAP_ENV__Text);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Reason *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
		return soap->error;
	if (soap->lang)
		soap_set_attr(soap, "xml:lang", soap->lang, 1);
	if (soap_out_string(soap, "SOAP-ENV:Text", -1, (char*const*)&a->SOAP_ENV__Text, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason *a, const char *type)
{
	size_t soap_flag_SOAP_ENV__Text = 1;
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	(void)type; /* appease -Wall -Werror */
	a = (struct SOAP_ENV__Reason*)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_SOAP_ENV__Reason(soap, a);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in_string(soap, "SOAP-ENV:Text", (char**)&a->SOAP_ENV__Text, "xsd:string"))
				{	soap_flag_SOAP_ENV__Text--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Reason, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, cross_finsert, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 cross_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_SOAP_ENV__Reason(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct SOAP_ENV__Reason *p;
	size_t k = sizeof(struct SOAP_ENV__Reason);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_SOAP_ENV__Reason, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct SOAP_ENV__Reason);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct SOAP_ENV__Reason, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct SOAP_ENV__Reason location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a, const char *tag, const char *type)
{
	if (soap_out_SOAP_ENV__Reason(soap, tag ? tag : "SOAP-ENV:Reason", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p, const char *tag, const char *type)
{
	if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->__any = NULL;
	a->__type = 0;
	a->fault = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_markelement(soap, a->fault, a->__type);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Detail *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
		return soap->error;
	if (soap_outliteral(soap, "-any", (char*const*)&a->__any, NULL))
		return soap->error;
	if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail *a, const char *type)
{
	size_t soap_flag___any = 1;
	size_t soap_flag_fault = 1;
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	(void)type; /* appease -Wall -Werror */
	a = (struct SOAP_ENV__Detail*)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_SOAP_ENV__Detail(soap, a);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
			{	if ((a->fault = soap_getelement(soap, "fault", &a->__type)))
				{	soap_flag_fault = 0;
					continue;
				}
			}
			if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_inliteral(soap, "-any", (char**)&a->__any))
				{	soap_flag___any--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Detail, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, cross_finsert, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 cross_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_SOAP_ENV__Detail(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct SOAP_ENV__Detail *p;
	size_t k = sizeof(struct SOAP_ENV__Detail);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_SOAP_ENV__Detail, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct SOAP_ENV__Detail);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct SOAP_ENV__Detail, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct SOAP_ENV__Detail location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a, const char *tag, const char *type)
{
	if (soap_out_SOAP_ENV__Detail(soap, tag ? tag : "SOAP-ENV:Detail", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p, const char *tag, const char *type)
{
	if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default__QName(soap, &a->SOAP_ENV__Value);
	a->SOAP_ENV__Subcode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize__QName(soap, (char*const*)&a->SOAP_ENV__Value);
	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Code *a, const char *type)
{
	const char *soap_tmp_SOAP_ENV__Value;
	soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
		return soap->error;
	if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)(void*)&soap_tmp_SOAP_ENV__Value, ""))
		return soap->error;
	if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code *a, const char *type)
{
	size_t soap_flag_SOAP_ENV__Value = 1;
	size_t soap_flag_SOAP_ENV__Subcode = 1;
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	(void)type; /* appease -Wall -Werror */
	a = (struct SOAP_ENV__Code*)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_SOAP_ENV__Code(soap, a);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
			{	if (soap_in__QName(soap, "SOAP-ENV:Value", (char**)&a->SOAP_ENV__Value, "xsd:QName"))
				{	soap_flag_SOAP_ENV__Value--;
					continue;
				}
			}
			if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
				{	soap_flag_SOAP_ENV__Subcode--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Code, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, cross_finsert, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 cross_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_SOAP_ENV__Code(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct SOAP_ENV__Code *p;
	size_t k = sizeof(struct SOAP_ENV__Code);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_SOAP_ENV__Code, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct SOAP_ENV__Code);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct SOAP_ENV__Code, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct SOAP_ENV__Code location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a, const char *tag, const char *type)
{
	if (soap_out_SOAP_ENV__Code(soap, tag ? tag : "SOAP-ENV:Code", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p, const char *tag, const char *type)
{
	if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap *soap, const char *tag, struct SOAP_ENV__Header *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	(void)type; /* appease -Wall -Werror */
	a = (struct SOAP_ENV__Header*)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_SOAP_ENV__Header(soap, a);
	if (soap->body && *soap->href != '#')
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap->error == SOAP_TAG_MISMATCH)
				soap->error = soap_ignore_element(soap);
			if (soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
		if (soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Header, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, cross_finsert, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 cross_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate_SOAP_ENV__Header(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct SOAP_ENV__Header *p;
	size_t k = sizeof(struct SOAP_ENV__Header);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE_SOAP_ENV__Header, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct SOAP_ENV__Header);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct SOAP_ENV__Header, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct SOAP_ENV__Header location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a, const char *tag, const char *type)
{
	if (soap_out_SOAP_ENV__Header(soap, tag ? tag : "SOAP-ENV:Header", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p, const char *tag, const char *type)
{
	if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__escrowResendSrv(struct soap *soap, struct __WS1__escrowResendSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__escrowResendSrv = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__escrowResendSrv(struct soap *soap, const struct __WS1__escrowResendSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__escrowResendSrv(soap, &a->WS1__escrowResendSrv);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__escrowResendSrv(struct soap *soap, const char *tag, int id, const struct __WS1__escrowResendSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__escrowResendSrv(soap, "WS1:escrowResendSrv", -1, &a->WS1__escrowResendSrv, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__escrowResendSrv * SOAP_FMAC4 soap_in___WS1__escrowResendSrv(struct soap *soap, const char *tag, struct __WS1__escrowResendSrv *a, const char *type)
{
	size_t soap_flag_WS1__escrowResendSrv = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__escrowResendSrv*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__escrowResendSrv, sizeof(struct __WS1__escrowResendSrv), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__escrowResendSrv(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__escrowResendSrv && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__escrowResendSrv(soap, "WS1:escrowResendSrv", &a->WS1__escrowResendSrv, ""))
				{	soap_flag_WS1__escrowResendSrv--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__escrowResendSrv * SOAP_FMAC2 cross_instantiate___WS1__escrowResendSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__escrowResendSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__escrowResendSrv *p;
	size_t k = sizeof(struct __WS1__escrowResendSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__escrowResendSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__escrowResendSrv);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__escrowResendSrv, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__escrowResendSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__escrowResendSrv(struct soap *soap, const struct __WS1__escrowResendSrv *a, const char *tag, const char *type)
{
	if (soap_out___WS1__escrowResendSrv(soap, tag ? tag : "-WS1:escrowResendSrv", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__escrowResendSrv * SOAP_FMAC4 soap_get___WS1__escrowResendSrv(struct soap *soap, struct __WS1__escrowResendSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__escrowResendSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeSrv(struct soap *soap, struct __WS1__invokeSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__invokeSrv = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeSrv(struct soap *soap, const struct __WS1__invokeSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__invokeSrv(soap, &a->WS1__invokeSrv);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeSrv(struct soap *soap, const char *tag, int id, const struct __WS1__invokeSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__invokeSrv(soap, "WS1:invokeSrv", -1, &a->WS1__invokeSrv, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeSrv * SOAP_FMAC4 soap_in___WS1__invokeSrv(struct soap *soap, const char *tag, struct __WS1__invokeSrv *a, const char *type)
{
	size_t soap_flag_WS1__invokeSrv = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__invokeSrv*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__invokeSrv, sizeof(struct __WS1__invokeSrv), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__invokeSrv(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__invokeSrv && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__invokeSrv(soap, "WS1:invokeSrv", &a->WS1__invokeSrv, ""))
				{	soap_flag_WS1__invokeSrv--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__invokeSrv * SOAP_FMAC2 cross_instantiate___WS1__invokeSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__invokeSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__invokeSrv *p;
	size_t k = sizeof(struct __WS1__invokeSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__invokeSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__invokeSrv);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__invokeSrv, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__invokeSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeSrv(struct soap *soap, const struct __WS1__invokeSrv *a, const char *tag, const char *type)
{
	if (soap_out___WS1__invokeSrv(soap, tag ? tag : "-WS1:invokeSrv", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeSrv * SOAP_FMAC4 soap_get___WS1__invokeSrv(struct soap *soap, struct __WS1__invokeSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__invokeSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regEAI(struct soap *soap, struct __WS1__regEAI *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__regEAI = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regEAI(struct soap *soap, const struct __WS1__regEAI *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__regEAI(soap, &a->WS1__regEAI);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regEAI(struct soap *soap, const char *tag, int id, const struct __WS1__regEAI *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__regEAI(soap, "WS1:regEAI", -1, &a->WS1__regEAI, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regEAI * SOAP_FMAC4 soap_in___WS1__regEAI(struct soap *soap, const char *tag, struct __WS1__regEAI *a, const char *type)
{
	size_t soap_flag_WS1__regEAI = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__regEAI*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__regEAI, sizeof(struct __WS1__regEAI), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__regEAI(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__regEAI && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__regEAI(soap, "WS1:regEAI", &a->WS1__regEAI, ""))
				{	soap_flag_WS1__regEAI--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__regEAI * SOAP_FMAC2 cross_instantiate___WS1__regEAI(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__regEAI(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__regEAI *p;
	size_t k = sizeof(struct __WS1__regEAI);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__regEAI, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__regEAI);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__regEAI, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__regEAI location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regEAI(struct soap *soap, const struct __WS1__regEAI *a, const char *tag, const char *type)
{
	if (soap_out___WS1__regEAI(soap, tag ? tag : "-WS1:regEAI", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regEAI * SOAP_FMAC4 soap_get___WS1__regEAI(struct soap *soap, struct __WS1__regEAI *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__regEAI(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regSrv(struct soap *soap, struct __WS1__regSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__regSrv = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regSrv(struct soap *soap, const struct __WS1__regSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__regSrv(soap, &a->WS1__regSrv);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regSrv(struct soap *soap, const char *tag, int id, const struct __WS1__regSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__regSrv(soap, "WS1:regSrv", -1, &a->WS1__regSrv, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regSrv * SOAP_FMAC4 soap_in___WS1__regSrv(struct soap *soap, const char *tag, struct __WS1__regSrv *a, const char *type)
{
	size_t soap_flag_WS1__regSrv = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__regSrv*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__regSrv, sizeof(struct __WS1__regSrv), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__regSrv(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__regSrv && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__regSrv(soap, "WS1:regSrv", &a->WS1__regSrv, ""))
				{	soap_flag_WS1__regSrv--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__regSrv * SOAP_FMAC2 cross_instantiate___WS1__regSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__regSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__regSrv *p;
	size_t k = sizeof(struct __WS1__regSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__regSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__regSrv);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__regSrv, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__regSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regSrv(struct soap *soap, const struct __WS1__regSrv *a, const char *tag, const char *type)
{
	if (soap_out___WS1__regSrv(soap, tag ? tag : "-WS1:regSrv", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regSrv * SOAP_FMAC4 soap_get___WS1__regSrv(struct soap *soap, struct __WS1__regSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__regSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getStandardDataNameList(struct soap *soap, struct __WS1__getStandardDataNameList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getStandardDataNameList = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getStandardDataNameList(struct soap *soap, const struct __WS1__getStandardDataNameList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getStandardDataNameList(soap, &a->WS1__getStandardDataNameList);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getStandardDataNameList(struct soap *soap, const char *tag, int id, const struct __WS1__getStandardDataNameList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getStandardDataNameList(soap, "WS1:getStandardDataNameList", -1, &a->WS1__getStandardDataNameList, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getStandardDataNameList * SOAP_FMAC4 soap_in___WS1__getStandardDataNameList(struct soap *soap, const char *tag, struct __WS1__getStandardDataNameList *a, const char *type)
{
	size_t soap_flag_WS1__getStandardDataNameList = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getStandardDataNameList*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getStandardDataNameList, sizeof(struct __WS1__getStandardDataNameList), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getStandardDataNameList(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getStandardDataNameList && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getStandardDataNameList(soap, "WS1:getStandardDataNameList", &a->WS1__getStandardDataNameList, ""))
				{	soap_flag_WS1__getStandardDataNameList--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getStandardDataNameList * SOAP_FMAC2 cross_instantiate___WS1__getStandardDataNameList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getStandardDataNameList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getStandardDataNameList *p;
	size_t k = sizeof(struct __WS1__getStandardDataNameList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getStandardDataNameList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getStandardDataNameList);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getStandardDataNameList, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getStandardDataNameList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getStandardDataNameList(struct soap *soap, const struct __WS1__getStandardDataNameList *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getStandardDataNameList(soap, tag ? tag : "-WS1:getStandardDataNameList", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getStandardDataNameList * SOAP_FMAC4 soap_get___WS1__getStandardDataNameList(struct soap *soap, struct __WS1__getStandardDataNameList *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getStandardDataNameList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getStandardServiceList(struct soap *soap, struct __WS1__getStandardServiceList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getStandardServiceList = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getStandardServiceList(struct soap *soap, const struct __WS1__getStandardServiceList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getStandardServiceList(soap, &a->WS1__getStandardServiceList);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getStandardServiceList(struct soap *soap, const char *tag, int id, const struct __WS1__getStandardServiceList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getStandardServiceList(soap, "WS1:getStandardServiceList", -1, &a->WS1__getStandardServiceList, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getStandardServiceList * SOAP_FMAC4 soap_in___WS1__getStandardServiceList(struct soap *soap, const char *tag, struct __WS1__getStandardServiceList *a, const char *type)
{
	size_t soap_flag_WS1__getStandardServiceList = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getStandardServiceList*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getStandardServiceList, sizeof(struct __WS1__getStandardServiceList), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getStandardServiceList(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getStandardServiceList && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getStandardServiceList(soap, "WS1:getStandardServiceList", &a->WS1__getStandardServiceList, ""))
				{	soap_flag_WS1__getStandardServiceList--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getStandardServiceList * SOAP_FMAC2 cross_instantiate___WS1__getStandardServiceList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getStandardServiceList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getStandardServiceList *p;
	size_t k = sizeof(struct __WS1__getStandardServiceList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getStandardServiceList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getStandardServiceList);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getStandardServiceList, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getStandardServiceList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getStandardServiceList(struct soap *soap, const struct __WS1__getStandardServiceList *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getStandardServiceList(soap, tag ? tag : "-WS1:getStandardServiceList", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getStandardServiceList * SOAP_FMAC4 soap_get___WS1__getStandardServiceList(struct soap *soap, struct __WS1__getStandardServiceList *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getStandardServiceList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__fpInvoke(struct soap *soap, struct __WS1__fpInvoke *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__fpInvoke = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__fpInvoke(struct soap *soap, const struct __WS1__fpInvoke *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__fpInvoke(soap, &a->WS1__fpInvoke);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__fpInvoke(struct soap *soap, const char *tag, int id, const struct __WS1__fpInvoke *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__fpInvoke(soap, "WS1:fpInvoke", -1, &a->WS1__fpInvoke, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__fpInvoke * SOAP_FMAC4 soap_in___WS1__fpInvoke(struct soap *soap, const char *tag, struct __WS1__fpInvoke *a, const char *type)
{
	size_t soap_flag_WS1__fpInvoke = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__fpInvoke*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__fpInvoke, sizeof(struct __WS1__fpInvoke), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__fpInvoke(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__fpInvoke && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__fpInvoke(soap, "WS1:fpInvoke", &a->WS1__fpInvoke, ""))
				{	soap_flag_WS1__fpInvoke--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__fpInvoke * SOAP_FMAC2 cross_instantiate___WS1__fpInvoke(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__fpInvoke(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__fpInvoke *p;
	size_t k = sizeof(struct __WS1__fpInvoke);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__fpInvoke, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__fpInvoke);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__fpInvoke, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__fpInvoke location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__fpInvoke(struct soap *soap, const struct __WS1__fpInvoke *a, const char *tag, const char *type)
{
	if (soap_out___WS1__fpInvoke(soap, tag ? tag : "-WS1:fpInvoke", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__fpInvoke * SOAP_FMAC4 soap_get___WS1__fpInvoke(struct soap *soap, struct __WS1__fpInvoke *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__fpInvoke(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getSrv(struct soap *soap, struct __WS1__getSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getSrv = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getSrv(struct soap *soap, const struct __WS1__getSrv *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getSrv(soap, &a->WS1__getSrv);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getSrv(struct soap *soap, const char *tag, int id, const struct __WS1__getSrv *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getSrv(soap, "WS1:getSrv", -1, &a->WS1__getSrv, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getSrv * SOAP_FMAC4 soap_in___WS1__getSrv(struct soap *soap, const char *tag, struct __WS1__getSrv *a, const char *type)
{
	size_t soap_flag_WS1__getSrv = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getSrv*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getSrv, sizeof(struct __WS1__getSrv), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getSrv(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getSrv && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getSrv(soap, "WS1:getSrv", &a->WS1__getSrv, ""))
				{	soap_flag_WS1__getSrv--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getSrv * SOAP_FMAC2 cross_instantiate___WS1__getSrv(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getSrv(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getSrv *p;
	size_t k = sizeof(struct __WS1__getSrv);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getSrv, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getSrv);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getSrv, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getSrv location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getSrv(struct soap *soap, const struct __WS1__getSrv *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getSrv(soap, tag ? tag : "-WS1:getSrv", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getSrv * SOAP_FMAC4 soap_get___WS1__getSrv(struct soap *soap, struct __WS1__getSrv *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getProd(struct soap *soap, struct __WS1__getProd *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getProd = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getProd(struct soap *soap, const struct __WS1__getProd *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getProd(soap, &a->WS1__getProd);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getProd(struct soap *soap, const char *tag, int id, const struct __WS1__getProd *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getProd(soap, "WS1:getProd", -1, &a->WS1__getProd, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getProd * SOAP_FMAC4 soap_in___WS1__getProd(struct soap *soap, const char *tag, struct __WS1__getProd *a, const char *type)
{
	size_t soap_flag_WS1__getProd = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getProd*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getProd, sizeof(struct __WS1__getProd), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getProd(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getProd && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getProd(soap, "WS1:getProd", &a->WS1__getProd, ""))
				{	soap_flag_WS1__getProd--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getProd * SOAP_FMAC2 cross_instantiate___WS1__getProd(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getProd(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getProd *p;
	size_t k = sizeof(struct __WS1__getProd);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getProd, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getProd);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getProd, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getProd location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getProd(struct soap *soap, const struct __WS1__getProd *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getProd(soap, tag ? tag : "-WS1:getProd", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getProd * SOAP_FMAC4 soap_get___WS1__getProd(struct soap *soap, struct __WS1__getProd *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getProd(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeMdm(struct soap *soap, struct __WS1__invokeMdm *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__invokeMdm = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeMdm(struct soap *soap, const struct __WS1__invokeMdm *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__invokeMdm(soap, &a->WS1__invokeMdm);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeMdm(struct soap *soap, const char *tag, int id, const struct __WS1__invokeMdm *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__invokeMdm(soap, "WS1:invokeMdm", -1, &a->WS1__invokeMdm, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeMdm * SOAP_FMAC4 soap_in___WS1__invokeMdm(struct soap *soap, const char *tag, struct __WS1__invokeMdm *a, const char *type)
{
	size_t soap_flag_WS1__invokeMdm = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__invokeMdm*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__invokeMdm, sizeof(struct __WS1__invokeMdm), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__invokeMdm(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__invokeMdm && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__invokeMdm(soap, "WS1:invokeMdm", &a->WS1__invokeMdm, ""))
				{	soap_flag_WS1__invokeMdm--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__invokeMdm * SOAP_FMAC2 cross_instantiate___WS1__invokeMdm(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__invokeMdm(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__invokeMdm *p;
	size_t k = sizeof(struct __WS1__invokeMdm);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__invokeMdm, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__invokeMdm);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__invokeMdm, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__invokeMdm location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeMdm(struct soap *soap, const struct __WS1__invokeMdm *a, const char *tag, const char *type)
{
	if (soap_out___WS1__invokeMdm(soap, tag ? tag : "-WS1:invokeMdm", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeMdm * SOAP_FMAC4 soap_get___WS1__invokeMdm(struct soap *soap, struct __WS1__invokeMdm *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__invokeMdm(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeUnion(struct soap *soap, struct __WS1__invokeUnion *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__invokeUnion = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeUnion(struct soap *soap, const struct __WS1__invokeUnion *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__invokeUnion(soap, &a->WS1__invokeUnion);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeUnion(struct soap *soap, const char *tag, int id, const struct __WS1__invokeUnion *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__invokeUnion(soap, "WS1:invokeUnion", -1, &a->WS1__invokeUnion, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeUnion * SOAP_FMAC4 soap_in___WS1__invokeUnion(struct soap *soap, const char *tag, struct __WS1__invokeUnion *a, const char *type)
{
	size_t soap_flag_WS1__invokeUnion = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__invokeUnion*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__invokeUnion, sizeof(struct __WS1__invokeUnion), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__invokeUnion(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__invokeUnion && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__invokeUnion(soap, "WS1:invokeUnion", &a->WS1__invokeUnion, ""))
				{	soap_flag_WS1__invokeUnion--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__invokeUnion * SOAP_FMAC2 cross_instantiate___WS1__invokeUnion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__invokeUnion(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__invokeUnion *p;
	size_t k = sizeof(struct __WS1__invokeUnion);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__invokeUnion, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__invokeUnion);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__invokeUnion, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__invokeUnion location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeUnion(struct soap *soap, const struct __WS1__invokeUnion *a, const char *tag, const char *type)
{
	if (soap_out___WS1__invokeUnion(soap, tag ? tag : "-WS1:invokeUnion", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeUnion * SOAP_FMAC4 soap_get___WS1__invokeUnion(struct soap *soap, struct __WS1__invokeUnion *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__invokeUnion(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__regProdAP(struct soap *soap, struct __WS1__regProdAP *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__regProdAP = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__regProdAP(struct soap *soap, const struct __WS1__regProdAP *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__regProdAP(soap, &a->WS1__regProdAP);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__regProdAP(struct soap *soap, const char *tag, int id, const struct __WS1__regProdAP *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__regProdAP(soap, "WS1:regProdAP", -1, &a->WS1__regProdAP, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regProdAP * SOAP_FMAC4 soap_in___WS1__regProdAP(struct soap *soap, const char *tag, struct __WS1__regProdAP *a, const char *type)
{
	size_t soap_flag_WS1__regProdAP = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__regProdAP*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__regProdAP, sizeof(struct __WS1__regProdAP), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__regProdAP(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__regProdAP && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__regProdAP(soap, "WS1:regProdAP", &a->WS1__regProdAP, ""))
				{	soap_flag_WS1__regProdAP--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__regProdAP * SOAP_FMAC2 cross_instantiate___WS1__regProdAP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__regProdAP(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__regProdAP *p;
	size_t k = sizeof(struct __WS1__regProdAP);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__regProdAP, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__regProdAP);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__regProdAP, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__regProdAP location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__regProdAP(struct soap *soap, const struct __WS1__regProdAP *a, const char *tag, const char *type)
{
	if (soap_out___WS1__regProdAP(soap, tag ? tag : "-WS1:regProdAP", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__regProdAP * SOAP_FMAC4 soap_get___WS1__regProdAP(struct soap *soap, struct __WS1__regProdAP *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__regProdAP(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getProdList(struct soap *soap, struct __WS1__getProdList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getProdList = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getProdList(struct soap *soap, const struct __WS1__getProdList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getProdList(soap, &a->WS1__getProdList);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getProdList(struct soap *soap, const char *tag, int id, const struct __WS1__getProdList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getProdList(soap, "WS1:getProdList", -1, &a->WS1__getProdList, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getProdList * SOAP_FMAC4 soap_in___WS1__getProdList(struct soap *soap, const char *tag, struct __WS1__getProdList *a, const char *type)
{
	size_t soap_flag_WS1__getProdList = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getProdList*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getProdList, sizeof(struct __WS1__getProdList), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getProdList(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getProdList && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getProdList(soap, "WS1:getProdList", &a->WS1__getProdList, ""))
				{	soap_flag_WS1__getProdList--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getProdList * SOAP_FMAC2 cross_instantiate___WS1__getProdList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getProdList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getProdList *p;
	size_t k = sizeof(struct __WS1__getProdList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getProdList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getProdList);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getProdList, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getProdList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getProdList(struct soap *soap, const struct __WS1__getProdList *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getProdList(soap, tag ? tag : "-WS1:getProdList", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getProdList * SOAP_FMAC4 soap_get___WS1__getProdList(struct soap *soap, struct __WS1__getProdList *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getProdList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getParamList(struct soap *soap, struct __WS1__getParamList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getParamList = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getParamList(struct soap *soap, const struct __WS1__getParamList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getParamList(soap, &a->WS1__getParamList);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getParamList(struct soap *soap, const char *tag, int id, const struct __WS1__getParamList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getParamList(soap, "WS1:getParamList", -1, &a->WS1__getParamList, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getParamList * SOAP_FMAC4 soap_in___WS1__getParamList(struct soap *soap, const char *tag, struct __WS1__getParamList *a, const char *type)
{
	size_t soap_flag_WS1__getParamList = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getParamList*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getParamList, sizeof(struct __WS1__getParamList), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getParamList(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getParamList && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getParamList(soap, "WS1:getParamList", &a->WS1__getParamList, ""))
				{	soap_flag_WS1__getParamList--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getParamList * SOAP_FMAC2 cross_instantiate___WS1__getParamList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getParamList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getParamList *p;
	size_t k = sizeof(struct __WS1__getParamList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getParamList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getParamList);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getParamList, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getParamList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getParamList(struct soap *soap, const struct __WS1__getParamList *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getParamList(soap, tag ? tag : "-WS1:getParamList", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getParamList * SOAP_FMAC4 soap_get___WS1__getParamList(struct soap *soap, struct __WS1__getParamList *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getParamList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__getEtlJobList(struct soap *soap, struct __WS1__getEtlJobList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__getEtlJobList = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__getEtlJobList(struct soap *soap, const struct __WS1__getEtlJobList *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__getEtlJobList(soap, &a->WS1__getEtlJobList);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__getEtlJobList(struct soap *soap, const char *tag, int id, const struct __WS1__getEtlJobList *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__getEtlJobList(soap, "WS1:getEtlJobList", -1, &a->WS1__getEtlJobList, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getEtlJobList * SOAP_FMAC4 soap_in___WS1__getEtlJobList(struct soap *soap, const char *tag, struct __WS1__getEtlJobList *a, const char *type)
{
	size_t soap_flag_WS1__getEtlJobList = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__getEtlJobList*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__getEtlJobList, sizeof(struct __WS1__getEtlJobList), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__getEtlJobList(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__getEtlJobList && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__getEtlJobList(soap, "WS1:getEtlJobList", &a->WS1__getEtlJobList, ""))
				{	soap_flag_WS1__getEtlJobList--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__getEtlJobList * SOAP_FMAC2 cross_instantiate___WS1__getEtlJobList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__getEtlJobList(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__getEtlJobList *p;
	size_t k = sizeof(struct __WS1__getEtlJobList);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__getEtlJobList, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__getEtlJobList);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__getEtlJobList, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__getEtlJobList location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__getEtlJobList(struct soap *soap, const struct __WS1__getEtlJobList *a, const char *tag, const char *type)
{
	if (soap_out___WS1__getEtlJobList(soap, tag ? tag : "-WS1:getEtlJobList", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__getEtlJobList * SOAP_FMAC4 soap_get___WS1__getEtlJobList(struct soap *soap, struct __WS1__getEtlJobList *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__getEtlJobList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default___WS1__invokeEtl(struct soap *soap, struct __WS1__invokeEtl *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->WS1__invokeEtl = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___WS1__invokeEtl(struct soap *soap, const struct __WS1__invokeEtl *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTo_WS1__invokeEtl(soap, &a->WS1__invokeEtl);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out___WS1__invokeEtl(struct soap *soap, const char *tag, int id, const struct __WS1__invokeEtl *a, const char *type)
{
	(void)soap; (void)tag; (void)id; (void)a; (void)type; /* appease -Wall -Werror */
	if (soap_out_PointerTo_WS1__invokeEtl(soap, "WS1:invokeEtl", -1, &a->WS1__invokeEtl, ""))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeEtl * SOAP_FMAC4 soap_in___WS1__invokeEtl(struct soap *soap, const char *tag, struct __WS1__invokeEtl *a, const char *type)
{
	size_t soap_flag_WS1__invokeEtl = 1;
	short soap_flag;
	(void)tag; (void)type; /* appease -Wall -Werror */
	a = (struct __WS1__invokeEtl*)soap_id_enter(soap, "", a, SOAP_TYPE___WS1__invokeEtl, sizeof(struct __WS1__invokeEtl), NULL, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default___WS1__invokeEtl(soap, a);
		for (soap_flag = 0;; soap_flag = 1)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_WS1__invokeEtl && soap->error == SOAP_TAG_MISMATCH)
			{	if (soap_in_PointerTo_WS1__invokeEtl(soap, "WS1:invokeEtl", &a->WS1__invokeEtl, ""))
				{	soap_flag_WS1__invokeEtl--;
					continue;
				}
			}
			if (soap->error == SOAP_TAG_MISMATCH && soap_flag)
			{	soap->error = SOAP_OK;
				break;
			}
			if (soap_flag && soap->error == SOAP_NO_TAG)
				break;
			if (soap->error)
				return NULL;
		}
	return a;
}

SOAP_FMAC1 struct __WS1__invokeEtl * SOAP_FMAC2 cross_instantiate___WS1__invokeEtl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "cross_instantiate___WS1__invokeEtl(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
	(void)type; (void)arrayType; /* appease -Wall -Werror */
	struct __WS1__invokeEtl *p;
	size_t k = sizeof(struct __WS1__invokeEtl);
	struct soap_clist *cp = soap_link(soap, SOAP_TYPE___WS1__invokeEtl, n, cross_fdelete);
	if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
		return NULL;
	if (n < 0)
	{	p = SOAP_NEW(soap, struct __WS1__invokeEtl);
	}
	else
	{	p = SOAP_NEW_ARRAY(soap, struct __WS1__invokeEtl, n);
		k *= n;
	}
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated struct __WS1__invokeEtl location=%p n=%d\n", (void*)p, n));
	if (size)
		*size = k;
	if (!p)
		soap->error = SOAP_EOM;
	else if (cp)
		cp->ptr = (void*)p;
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put___WS1__invokeEtl(struct soap *soap, const struct __WS1__invokeEtl *a, const char *tag, const char *type)
{
	if (soap_out___WS1__invokeEtl(soap, tag ? tag : "-WS1:invokeEtl", -2, a, type))
		return soap->error;
	return SOAP_OK;
}

SOAP_FMAC3 struct __WS1__invokeEtl * SOAP_FMAC4 soap_get___WS1__invokeEtl(struct soap *soap, struct __WS1__invokeEtl *p, const char *tag, const char *type)
{
	if ((p = soap_in___WS1__invokeEtl(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
		soap_serialize_SOAP_ENV__Reason(soap, *a);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Reason *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason, NULL);
	if (id < 0)
		return soap->error;
	return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
}

SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerToSOAP_ENV__Reason(soap, tag ? tag : "SOAP-ENV:Reason", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
		soap_serialize_SOAP_ENV__Detail(soap, *a);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Detail *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail, NULL);
	if (id < 0)
		return soap->error;
	return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
}

SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerToSOAP_ENV__Detail(soap, tag ? tag : "SOAP-ENV:Detail", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
		soap_serialize_SOAP_ENV__Code(soap, *a);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type)
{
	char *mark;
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code, &mark);
	if (id < 0)
		return soap->error;
	(void)soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
	soap_unmark(soap, mark);
	return soap->error;
}

SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerToSOAP_ENV__Code(soap, tag ? tag : "SOAP-ENV:Code", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#endif

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__escrowResendSrv))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__escrowResendSrv(struct soap *soap, const char *tag, int id, _WS1__escrowResendSrv *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__escrowResendSrv, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__escrowResendSrv ? type : NULL);
}

SOAP_FMAC3 _WS1__escrowResendSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__escrowResendSrv(struct soap *soap, const char *tag, _WS1__escrowResendSrv **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__escrowResendSrv **)soap_malloc(soap, sizeof(_WS1__escrowResendSrv *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__escrowResendSrv *)cross_instantiate__WS1__escrowResendSrv(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__escrowResendSrv **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__escrowResendSrv, sizeof(_WS1__escrowResendSrv), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__escrowResendSrv(soap, tag ? tag : "WS1:escrowResendSrv", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__escrowResendSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__escrowResendSrv(struct soap *soap, _WS1__escrowResendSrv **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__escrowResendSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__invokeSrv))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeSrv(struct soap *soap, const char *tag, int id, _WS1__invokeSrv *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__invokeSrv, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__invokeSrv ? type : NULL);
}

SOAP_FMAC3 _WS1__invokeSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeSrv(struct soap *soap, const char *tag, _WS1__invokeSrv **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__invokeSrv **)soap_malloc(soap, sizeof(_WS1__invokeSrv *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__invokeSrv *)cross_instantiate__WS1__invokeSrv(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__invokeSrv **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__invokeSrv, sizeof(_WS1__invokeSrv), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__invokeSrv(soap, tag ? tag : "WS1:invokeSrv", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__invokeSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeSrv(struct soap *soap, _WS1__invokeSrv **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__invokeSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regEAI(struct soap *soap, _WS1__regEAI *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__regEAI))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regEAI(struct soap *soap, const char *tag, int id, _WS1__regEAI *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__regEAI, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__regEAI ? type : NULL);
}

SOAP_FMAC3 _WS1__regEAI ** SOAP_FMAC4 soap_in_PointerTo_WS1__regEAI(struct soap *soap, const char *tag, _WS1__regEAI **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__regEAI **)soap_malloc(soap, sizeof(_WS1__regEAI *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__regEAI *)cross_instantiate__WS1__regEAI(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__regEAI **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__regEAI, sizeof(_WS1__regEAI), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regEAI(struct soap *soap, _WS1__regEAI *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__regEAI(soap, tag ? tag : "WS1:regEAI", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__regEAI ** SOAP_FMAC4 soap_get_PointerTo_WS1__regEAI(struct soap *soap, _WS1__regEAI **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__regEAI(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regSrv(struct soap *soap, _WS1__regSrv *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__regSrv))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regSrv(struct soap *soap, const char *tag, int id, _WS1__regSrv *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__regSrv, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__regSrv ? type : NULL);
}

SOAP_FMAC3 _WS1__regSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__regSrv(struct soap *soap, const char *tag, _WS1__regSrv **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__regSrv **)soap_malloc(soap, sizeof(_WS1__regSrv *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__regSrv *)cross_instantiate__WS1__regSrv(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__regSrv **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__regSrv, sizeof(_WS1__regSrv), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regSrv(struct soap *soap, _WS1__regSrv *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__regSrv(soap, tag ? tag : "WS1:regSrv", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__regSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__regSrv(struct soap *soap, _WS1__regSrv **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__regSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getStandardDataNameList))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getStandardDataNameList(struct soap *soap, const char *tag, int id, _WS1__getStandardDataNameList *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getStandardDataNameList, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getStandardDataNameList ? type : NULL);
}

SOAP_FMAC3 _WS1__getStandardDataNameList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getStandardDataNameList(struct soap *soap, const char *tag, _WS1__getStandardDataNameList **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getStandardDataNameList **)soap_malloc(soap, sizeof(_WS1__getStandardDataNameList *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getStandardDataNameList *)cross_instantiate__WS1__getStandardDataNameList(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getStandardDataNameList **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getStandardDataNameList, sizeof(_WS1__getStandardDataNameList), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getStandardDataNameList(soap, tag ? tag : "WS1:getStandardDataNameList", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getStandardDataNameList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getStandardDataNameList(struct soap *soap, _WS1__getStandardDataNameList **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getStandardDataNameList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getStandardServiceList))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getStandardServiceList(struct soap *soap, const char *tag, int id, _WS1__getStandardServiceList *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getStandardServiceList, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getStandardServiceList ? type : NULL);
}

SOAP_FMAC3 _WS1__getStandardServiceList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getStandardServiceList(struct soap *soap, const char *tag, _WS1__getStandardServiceList **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getStandardServiceList **)soap_malloc(soap, sizeof(_WS1__getStandardServiceList *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getStandardServiceList *)cross_instantiate__WS1__getStandardServiceList(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getStandardServiceList **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getStandardServiceList, sizeof(_WS1__getStandardServiceList), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getStandardServiceList(soap, tag ? tag : "WS1:getStandardServiceList", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getStandardServiceList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getStandardServiceList(struct soap *soap, _WS1__getStandardServiceList **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getStandardServiceList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__fpInvoke))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__fpInvoke(struct soap *soap, const char *tag, int id, _WS1__fpInvoke *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__fpInvoke, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__fpInvoke ? type : NULL);
}

SOAP_FMAC3 _WS1__fpInvoke ** SOAP_FMAC4 soap_in_PointerTo_WS1__fpInvoke(struct soap *soap, const char *tag, _WS1__fpInvoke **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__fpInvoke **)soap_malloc(soap, sizeof(_WS1__fpInvoke *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__fpInvoke *)cross_instantiate__WS1__fpInvoke(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__fpInvoke **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__fpInvoke, sizeof(_WS1__fpInvoke), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__fpInvoke(soap, tag ? tag : "WS1:fpInvoke", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__fpInvoke ** SOAP_FMAC4 soap_get_PointerTo_WS1__fpInvoke(struct soap *soap, _WS1__fpInvoke **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__fpInvoke(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getSrv(struct soap *soap, _WS1__getSrv *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getSrv))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getSrv(struct soap *soap, const char *tag, int id, _WS1__getSrv *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getSrv, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getSrv ? type : NULL);
}

SOAP_FMAC3 _WS1__getSrv ** SOAP_FMAC4 soap_in_PointerTo_WS1__getSrv(struct soap *soap, const char *tag, _WS1__getSrv **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getSrv **)soap_malloc(soap, sizeof(_WS1__getSrv *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getSrv *)cross_instantiate__WS1__getSrv(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getSrv **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getSrv, sizeof(_WS1__getSrv), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getSrv(struct soap *soap, _WS1__getSrv *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getSrv(soap, tag ? tag : "WS1:getSrv", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getSrv ** SOAP_FMAC4 soap_get_PointerTo_WS1__getSrv(struct soap *soap, _WS1__getSrv **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getSrv(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getProd(struct soap *soap, _WS1__getProd *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getProd))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getProd(struct soap *soap, const char *tag, int id, _WS1__getProd *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getProd, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getProd ? type : NULL);
}

SOAP_FMAC3 _WS1__getProd ** SOAP_FMAC4 soap_in_PointerTo_WS1__getProd(struct soap *soap, const char *tag, _WS1__getProd **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getProd **)soap_malloc(soap, sizeof(_WS1__getProd *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getProd *)cross_instantiate__WS1__getProd(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getProd **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getProd, sizeof(_WS1__getProd), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getProd(struct soap *soap, _WS1__getProd *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getProd(soap, tag ? tag : "WS1:getProd", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getProd ** SOAP_FMAC4 soap_get_PointerTo_WS1__getProd(struct soap *soap, _WS1__getProd **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getProd(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__invokeMdm))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeMdm(struct soap *soap, const char *tag, int id, _WS1__invokeMdm *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__invokeMdm, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__invokeMdm ? type : NULL);
}

SOAP_FMAC3 _WS1__invokeMdm ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeMdm(struct soap *soap, const char *tag, _WS1__invokeMdm **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__invokeMdm **)soap_malloc(soap, sizeof(_WS1__invokeMdm *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__invokeMdm *)cross_instantiate__WS1__invokeMdm(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__invokeMdm **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__invokeMdm, sizeof(_WS1__invokeMdm), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__invokeMdm(soap, tag ? tag : "WS1:invokeMdm", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__invokeMdm ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeMdm(struct soap *soap, _WS1__invokeMdm **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__invokeMdm(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__invokeUnion))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeUnion(struct soap *soap, const char *tag, int id, _WS1__invokeUnion *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__invokeUnion, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__invokeUnion ? type : NULL);
}

SOAP_FMAC3 _WS1__invokeUnion ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeUnion(struct soap *soap, const char *tag, _WS1__invokeUnion **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__invokeUnion **)soap_malloc(soap, sizeof(_WS1__invokeUnion *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__invokeUnion *)cross_instantiate__WS1__invokeUnion(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__invokeUnion **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__invokeUnion, sizeof(_WS1__invokeUnion), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__invokeUnion(soap, tag ? tag : "WS1:invokeUnion", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__invokeUnion ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeUnion(struct soap *soap, _WS1__invokeUnion **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__invokeUnion(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__regProdAP(struct soap *soap, _WS1__regProdAP *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__regProdAP))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__regProdAP(struct soap *soap, const char *tag, int id, _WS1__regProdAP *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__regProdAP, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__regProdAP ? type : NULL);
}

SOAP_FMAC3 _WS1__regProdAP ** SOAP_FMAC4 soap_in_PointerTo_WS1__regProdAP(struct soap *soap, const char *tag, _WS1__regProdAP **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__regProdAP **)soap_malloc(soap, sizeof(_WS1__regProdAP *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__regProdAP *)cross_instantiate__WS1__regProdAP(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__regProdAP **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__regProdAP, sizeof(_WS1__regProdAP), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__regProdAP(struct soap *soap, _WS1__regProdAP *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__regProdAP(soap, tag ? tag : "WS1:regProdAP", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__regProdAP ** SOAP_FMAC4 soap_get_PointerTo_WS1__regProdAP(struct soap *soap, _WS1__regProdAP **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__regProdAP(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getProdList(struct soap *soap, _WS1__getProdList *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getProdList))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getProdList(struct soap *soap, const char *tag, int id, _WS1__getProdList *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getProdList, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getProdList ? type : NULL);
}

SOAP_FMAC3 _WS1__getProdList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getProdList(struct soap *soap, const char *tag, _WS1__getProdList **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getProdList **)soap_malloc(soap, sizeof(_WS1__getProdList *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getProdList *)cross_instantiate__WS1__getProdList(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getProdList **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getProdList, sizeof(_WS1__getProdList), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getProdList(struct soap *soap, _WS1__getProdList *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getProdList(soap, tag ? tag : "WS1:getProdList", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getProdList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getProdList(struct soap *soap, _WS1__getProdList **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getProdList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getParamList(struct soap *soap, _WS1__getParamList *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getParamList))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getParamList(struct soap *soap, const char *tag, int id, _WS1__getParamList *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getParamList, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getParamList ? type : NULL);
}

SOAP_FMAC3 _WS1__getParamList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getParamList(struct soap *soap, const char *tag, _WS1__getParamList **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getParamList **)soap_malloc(soap, sizeof(_WS1__getParamList *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getParamList *)cross_instantiate__WS1__getParamList(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getParamList **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getParamList, sizeof(_WS1__getParamList), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getParamList(struct soap *soap, _WS1__getParamList *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getParamList(soap, tag ? tag : "WS1:getParamList", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getParamList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getParamList(struct soap *soap, _WS1__getParamList **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getParamList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__getEtlJobList))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__getEtlJobList(struct soap *soap, const char *tag, int id, _WS1__getEtlJobList *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__getEtlJobList, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__getEtlJobList ? type : NULL);
}

SOAP_FMAC3 _WS1__getEtlJobList ** SOAP_FMAC4 soap_in_PointerTo_WS1__getEtlJobList(struct soap *soap, const char *tag, _WS1__getEtlJobList **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__getEtlJobList **)soap_malloc(soap, sizeof(_WS1__getEtlJobList *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__getEtlJobList *)cross_instantiate__WS1__getEtlJobList(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__getEtlJobList **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__getEtlJobList, sizeof(_WS1__getEtlJobList), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__getEtlJobList(soap, tag ? tag : "WS1:getEtlJobList", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__getEtlJobList ** SOAP_FMAC4 soap_get_PointerTo_WS1__getEtlJobList(struct soap *soap, _WS1__getEtlJobList **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__getEtlJobList(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE__WS1__invokeEtl))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_WS1__invokeEtl(struct soap *soap, const char *tag, int id, _WS1__invokeEtl *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__WS1__invokeEtl, NULL);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__WS1__invokeEtl ? type : NULL);
}

SOAP_FMAC3 _WS1__invokeEtl ** SOAP_FMAC4 soap_in_PointerTo_WS1__invokeEtl(struct soap *soap, const char *tag, _WS1__invokeEtl **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (_WS1__invokeEtl **)soap_malloc(soap, sizeof(_WS1__invokeEtl *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (_WS1__invokeEtl *)cross_instantiate__WS1__invokeEtl(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
		{	*a = NULL;
			return NULL;
		}
	}
	else
	{	a = (_WS1__invokeEtl **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__WS1__invokeEtl, sizeof(_WS1__invokeEtl), 0, cross_fbase);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl *const*a, const char *tag, const char *type)
{
	if (soap_out_PointerTo_WS1__invokeEtl(soap, tag ? tag : "WS1:invokeEtl", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 _WS1__invokeEtl ** SOAP_FMAC4 soap_get_PointerTo_WS1__invokeEtl(struct soap *soap, _WS1__invokeEtl **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTo_WS1__invokeEtl(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	(void)soap_reference(soap, *a, SOAP_TYPE__QName);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
{
	return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
}

SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
{
	a = soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, 0, -1, NULL);
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
{
	if (soap_out__QName(soap, tag ? tag : "QName", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
{
	if ((p = soap_in__QName(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	(void)soap_reference(soap, *a, SOAP_TYPE_string);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
{
	return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
}

SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
{
	a = soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, 0, -1, NULL);
	return a;
}

SOAP_FMAC3 char * * SOAP_FMAC4 soap_new_string(struct soap *soap, int n)
{
	char * *a = static_cast<char * *>(soap_malloc(soap, (n = (n < 0 ? 1 : n)) * sizeof(char *)));
	for (char * *p = a; p && n--; ++p)
		soap_default_string(soap, p);
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
{
	if (soap_out_string(soap, tag ? tag : "string", -2, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
{
	if ((p = soap_in_string(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

#if defined(__BORLANDC__)
#pragma option pop
#pragma option pop
#endif

/* End of crossC.cpp */
