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

#include "soapH.h"

SOAP_SOURCE_STAMP("@(#) soapC.cpp ver 2.8.21 2015-04-01 08:10:34 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, NULL))
			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, -1)))
			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;
		soap_default_SOAP_ENV__Fault(soap, soap->fault);
	}
	if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
	{	soap->fault->SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap, -1);
		soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
	}
	if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
	{	soap->fault->SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap, -1);
		soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
	}
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
{
	soap_fault(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", NULL);
	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->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->version == 2)
	{	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);
			soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
		}
		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_check_faultsubcode(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
	{	if (soap->fault->SOAP_ENV__Code && soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode && soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
			return soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
		return NULL;
	}
	return soap->fault->faultcode;
}

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
		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_faultdetail(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2)
	{	if (soap->fault->SOAP_ENV__Detail == NULL)
		{	soap->fault->SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap, -1);
			soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
		}
		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);
		soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
	}
	return (const char**)(void*)&soap->fault->detail->__any;
}

SOAP_FMAC3 const char * SOAP_FMAC4 soap_check_faultdetail(struct soap *soap)
{
	soap_fault(soap);
	if (soap->version == 2 && soap->fault->SOAP_ENV__Detail)
		return soap->fault->SOAP_ENV__Detail->__any;
	if (soap->fault->detail)
		return soap->fault->detail->__any;
	return 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, &t))
				if (soap->error || soap_ignore_element(soap))
					break;
		}
	}
	if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
		soap->error = SOAP_OK;
	return soap->error;
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, 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, NULL, NULL, "xsd:byte");
	case SOAP_TYPE_short:
		return soap_in_short(soap, NULL, NULL, "xsd:short");
	case SOAP_TYPE_int:
		return soap_in_int(soap, NULL, NULL, "xsd:int");
	case SOAP_TYPE_double:
		return soap_in_double(soap, NULL, NULL, "xsd:double");
	case SOAP_TYPE_unsignedShort:
		return soap_in_unsignedShort(soap, NULL, NULL, "xsd:unsignedShort");
	case SOAP_TYPE_unsignedInt:
		return soap_in_unsignedInt(soap, NULL, NULL, "xsd:unsignedInt");
	case SOAP_TYPE_bool:
		return soap_in_bool(soap, NULL, NULL, "xsd:boolean");
	case SOAP_TYPE_ns__AddrFamily:
		return soap_in_ns__AddrFamily(soap, NULL, NULL, "ns:AddrFamily");
	case SOAP_TYPE_ns__Policy:
		return soap_in_ns__Policy(soap, NULL, NULL, "ns:Policy");
	case SOAP_TYPE_ns__ErrorCode:
		return soap_in_ns__ErrorCode(soap, NULL, NULL, "ns:ErrorCode");
	case SOAP_TYPE_ns__ConferenceInfoResult:
		return soap_in_ns__ConferenceInfoResult(soap, NULL, NULL, "ns:ConferenceInfoResult");
	case SOAP_TYPE_ns__ConferenceListResult:
		return soap_in_ns__ConferenceListResult(soap, NULL, NULL, "ns:ConferenceListResult");
	case SOAP_TYPE_xsd__string:
		return soap_in_xsd__string(soap, NULL, NULL, "xsd:string");
	case SOAP_TYPE_std__string:
		return soap_in_std__string(soap, NULL, NULL, "xsd:string");
	case SOAP_TYPE_ns__getConferenceInfo:
		return soap_in_ns__getConferenceInfo(soap, NULL, NULL, "ns:getConferenceInfo");
	case SOAP_TYPE_ns__getConferenceIDs:
		return soap_in_ns__getConferenceIDs(soap, NULL, NULL, "ns:getConferenceIDs");
	case SOAP_TYPE_ns__removeChair:
		return soap_in_ns__removeChair(soap, NULL, NULL, "ns:removeChair");
	case SOAP_TYPE_ns__removeChairResponse:
		return soap_in_ns__removeChairResponse(soap, NULL, NULL, "ns:removeChairResponse");
	case SOAP_TYPE_ns__setChair:
		return soap_in_ns__setChair(soap, NULL, NULL, "ns:setChair");
	case SOAP_TYPE_ns__setChairResponse:
		return soap_in_ns__setChairResponse(soap, NULL, NULL, "ns:setChairResponse");
	case SOAP_TYPE_ns__removeUser:
		return soap_in_ns__removeUser(soap, NULL, NULL, "ns:removeUser");
	case SOAP_TYPE_ns__removeUserResponse:
		return soap_in_ns__removeUserResponse(soap, NULL, NULL, "ns:removeUserResponse");
	case SOAP_TYPE_ns__addUser:
		return soap_in_ns__addUser(soap, NULL, NULL, "ns:addUser");
	case SOAP_TYPE_ns__addUserResponse:
		return soap_in_ns__addUserResponse(soap, NULL, NULL, "ns:addUserResponse");
	case SOAP_TYPE_ns__modifyFloor:
		return soap_in_ns__modifyFloor(soap, NULL, NULL, "ns:modifyFloor");
	case SOAP_TYPE_ns__modifyFloorResponse:
		return soap_in_ns__modifyFloorResponse(soap, NULL, NULL, "ns:modifyFloorResponse");
	case SOAP_TYPE_ns__removeFloor:
		return soap_in_ns__removeFloor(soap, NULL, NULL, "ns:removeFloor");
	case SOAP_TYPE_ns__removeFloorResponse:
		return soap_in_ns__removeFloorResponse(soap, NULL, NULL, "ns:removeFloorResponse");
	case SOAP_TYPE_ns__addFloor:
		return soap_in_ns__addFloor(soap, NULL, NULL, "ns:addFloor");
	case SOAP_TYPE_ns__addFloorResponse:
		return soap_in_ns__addFloorResponse(soap, NULL, NULL, "ns:addFloorResponse");
	case SOAP_TYPE_ns__modifyConference:
		return soap_in_ns__modifyConference(soap, NULL, NULL, "ns:modifyConference");
	case SOAP_TYPE_ns__modifyConferenceResponse:
		return soap_in_ns__modifyConferenceResponse(soap, NULL, NULL, "ns:modifyConferenceResponse");
	case SOAP_TYPE_ns__removeConference:
		return soap_in_ns__removeConference(soap, NULL, NULL, "ns:removeConference");
	case SOAP_TYPE_ns__removeConferenceResponse:
		return soap_in_ns__removeConferenceResponse(soap, NULL, NULL, "ns:removeConferenceResponse");
	case SOAP_TYPE_ns__addConference:
		return soap_in_ns__addConference(soap, NULL, NULL, "ns:addConference");
	case SOAP_TYPE_ns__addConferenceResponse:
		return soap_in_ns__addConferenceResponse(soap, NULL, NULL, "ns:addConferenceResponse");
	case SOAP_TYPE_ns__quit:
		return soap_in_ns__quit(soap, NULL, NULL, "ns:quit");
	case SOAP_TYPE_ns__stop:
		return soap_in_ns__stop(soap, NULL, NULL, "ns:stop");
	case SOAP_TYPE_ns__stopResponse:
		return soap_in_ns__stopResponse(soap, NULL, NULL, "ns:stopResponse");
	case SOAP_TYPE_ns__start:
		return soap_in_ns__start(soap, NULL, NULL, "ns:start");
	case SOAP_TYPE_ns__startResponse:
		return soap_in_ns__startResponse(soap, NULL, NULL, "ns:startResponse");
	case SOAP_TYPE_PointerTons__ConferenceInfoResult:
		return soap_in_PointerTons__ConferenceInfoResult(soap, NULL, NULL, "ns:ConferenceInfoResult");
	case SOAP_TYPE_PointerTons__ConferenceListResult:
		return soap_in_PointerTons__ConferenceListResult(soap, NULL, NULL, "ns:ConferenceListResult");
	case SOAP_TYPE_PointerTons__ErrorCode:
		return soap_in_PointerTons__ErrorCode(soap, NULL, NULL, "ns:ErrorCode");
	case SOAP_TYPE__QName:
	{	char **s;
		s = soap_in__QName(soap, NULL, NULL, "xsd:QName");
		return s ? *s : NULL;
	}
	case SOAP_TYPE_string:
	{	char **s;
		s = soap_in_string(soap, NULL, 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, "ns:ConferenceInfoResult"))
		{	*type = SOAP_TYPE_ns__ConferenceInfoResult;
			return soap_in_ns__ConferenceInfoResult(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:ConferenceListResult"))
		{	*type = SOAP_TYPE_ns__ConferenceListResult;
			return soap_in_ns__ConferenceListResult(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:string"))
		{	*type = SOAP_TYPE_xsd__string;
			return soap_in_xsd__string(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:string"))
		{	*type = SOAP_TYPE_std__string;
			return soap_in_std__string(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:byte"))
		{	*type = SOAP_TYPE_byte;
			return soap_in_byte(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:short"))
		{	*type = SOAP_TYPE_short;
			return soap_in_short(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:int"))
		{	*type = SOAP_TYPE_int;
			return soap_in_int(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:double"))
		{	*type = SOAP_TYPE_double;
			return soap_in_double(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:unsignedShort"))
		{	*type = SOAP_TYPE_unsignedShort;
			return soap_in_unsignedShort(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:unsignedInt"))
		{	*type = SOAP_TYPE_unsignedInt;
			return soap_in_unsignedInt(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:boolean"))
		{	*type = SOAP_TYPE_bool;
			return soap_in_bool(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:AddrFamily"))
		{	*type = SOAP_TYPE_ns__AddrFamily;
			return soap_in_ns__AddrFamily(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:Policy"))
		{	*type = SOAP_TYPE_ns__Policy;
			return soap_in_ns__Policy(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:ErrorCode"))
		{	*type = SOAP_TYPE_ns__ErrorCode;
			return soap_in_ns__ErrorCode(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:getConferenceInfo"))
		{	*type = SOAP_TYPE_ns__getConferenceInfo;
			return soap_in_ns__getConferenceInfo(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:getConferenceIDs"))
		{	*type = SOAP_TYPE_ns__getConferenceIDs;
			return soap_in_ns__getConferenceIDs(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeChair"))
		{	*type = SOAP_TYPE_ns__removeChair;
			return soap_in_ns__removeChair(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeChairResponse"))
		{	*type = SOAP_TYPE_ns__removeChairResponse;
			return soap_in_ns__removeChairResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:setChair"))
		{	*type = SOAP_TYPE_ns__setChair;
			return soap_in_ns__setChair(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:setChairResponse"))
		{	*type = SOAP_TYPE_ns__setChairResponse;
			return soap_in_ns__setChairResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeUser"))
		{	*type = SOAP_TYPE_ns__removeUser;
			return soap_in_ns__removeUser(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeUserResponse"))
		{	*type = SOAP_TYPE_ns__removeUserResponse;
			return soap_in_ns__removeUserResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addUser"))
		{	*type = SOAP_TYPE_ns__addUser;
			return soap_in_ns__addUser(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addUserResponse"))
		{	*type = SOAP_TYPE_ns__addUserResponse;
			return soap_in_ns__addUserResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:modifyFloor"))
		{	*type = SOAP_TYPE_ns__modifyFloor;
			return soap_in_ns__modifyFloor(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:modifyFloorResponse"))
		{	*type = SOAP_TYPE_ns__modifyFloorResponse;
			return soap_in_ns__modifyFloorResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeFloor"))
		{	*type = SOAP_TYPE_ns__removeFloor;
			return soap_in_ns__removeFloor(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeFloorResponse"))
		{	*type = SOAP_TYPE_ns__removeFloorResponse;
			return soap_in_ns__removeFloorResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addFloor"))
		{	*type = SOAP_TYPE_ns__addFloor;
			return soap_in_ns__addFloor(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addFloorResponse"))
		{	*type = SOAP_TYPE_ns__addFloorResponse;
			return soap_in_ns__addFloorResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:modifyConference"))
		{	*type = SOAP_TYPE_ns__modifyConference;
			return soap_in_ns__modifyConference(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:modifyConferenceResponse"))
		{	*type = SOAP_TYPE_ns__modifyConferenceResponse;
			return soap_in_ns__modifyConferenceResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeConference"))
		{	*type = SOAP_TYPE_ns__removeConference;
			return soap_in_ns__removeConference(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:removeConferenceResponse"))
		{	*type = SOAP_TYPE_ns__removeConferenceResponse;
			return soap_in_ns__removeConferenceResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addConference"))
		{	*type = SOAP_TYPE_ns__addConference;
			return soap_in_ns__addConference(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:addConferenceResponse"))
		{	*type = SOAP_TYPE_ns__addConferenceResponse;
			return soap_in_ns__addConferenceResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:quit"))
		{	*type = SOAP_TYPE_ns__quit;
			return soap_in_ns__quit(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:stop"))
		{	*type = SOAP_TYPE_ns__stop;
			return soap_in_ns__stop(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:stopResponse"))
		{	*type = SOAP_TYPE_ns__stopResponse;
			return soap_in_ns__stopResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:start"))
		{	*type = SOAP_TYPE_ns__start;
			return soap_in_ns__start(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "ns:startResponse"))
		{	*type = SOAP_TYPE_ns__startResponse;
			return soap_in_ns__startResponse(soap, NULL, NULL, NULL);
		}
		if (!soap_match_tag(soap, t, "xsd:QName"))
		{	char **s;
			*type = SOAP_TYPE__QName;
			s = soap_in__QName(soap, NULL, 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, NULL, NULL, NULL);
			return s ? *s : NULL;
		}
		t = soap->tag;
#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)
			return soap->error = SOAP_MUSTUNDERSTAND;
		if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
		{	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
			return soap->error = SOAP_TAG_MISMATCH;
		}
		if (!*soap->id || !soap_getelement(soap, &t))
		{	soap->peeked = 0;
			if (soap->fignore)
				soap->error = soap->fignore(soap, soap->tag);
			else
				soap->error = SOAP_OK;
			DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
			if (!soap->error && soap->body)
			{	soap->level++;
				while (!soap_ignore_element(soap))
					;
				if (soap->error == SOAP_NO_TAG)
					soap->error = soap_element_end_in(soap, NULL);
			}
		}
	}
	return soap->error;
}

#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_short:
		return soap_out_short(soap, tag, id, (const short *)ptr, "xsd:short");
	case SOAP_TYPE_int:
		return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
	case SOAP_TYPE_double:
		return soap_out_double(soap, tag, id, (const double *)ptr, "xsd:double");
	case SOAP_TYPE_unsignedShort:
		return soap_out_unsignedShort(soap, tag, id, (const unsigned short *)ptr, "xsd:unsignedShort");
	case SOAP_TYPE_unsignedInt:
		return soap_out_unsignedInt(soap, tag, id, (const unsigned int *)ptr, "xsd:unsignedInt");
	case SOAP_TYPE_bool:
		return soap_out_bool(soap, tag, id, (const bool *)ptr, "xsd:boolean");
	case SOAP_TYPE_ns__AddrFamily:
		return soap_out_ns__AddrFamily(soap, tag, id, (const enum ns__AddrFamily *)ptr, "ns:AddrFamily");
	case SOAP_TYPE_ns__Policy:
		return soap_out_ns__Policy(soap, tag, id, (const enum ns__Policy *)ptr, "ns:Policy");
	case SOAP_TYPE_ns__ErrorCode:
		return soap_out_ns__ErrorCode(soap, tag, id, (const enum ns__ErrorCode *)ptr, "ns:ErrorCode");
	case SOAP_TYPE_ns__ConferenceInfoResult:
		return ((ns__ConferenceInfoResult *)ptr)->soap_out(soap, tag, id, "ns:ConferenceInfoResult");
	case SOAP_TYPE_ns__ConferenceListResult:
		return ((ns__ConferenceListResult *)ptr)->soap_out(soap, tag, id, "ns:ConferenceListResult");
	case SOAP_TYPE_xsd__string:
		return soap_out_xsd__string(soap, tag, id, (const std::string *)ptr, "xsd:string");
	case SOAP_TYPE_std__string:
		return soap_out_std__string(soap, tag, id, (const std::string *)ptr, "xsd:string");
	case SOAP_TYPE_ns__getConferenceInfo:
		return soap_out_ns__getConferenceInfo(soap, tag, id, (const struct ns__getConferenceInfo *)ptr, "ns:getConferenceInfo");
	case SOAP_TYPE_ns__getConferenceIDs:
		return soap_out_ns__getConferenceIDs(soap, tag, id, (const struct ns__getConferenceIDs *)ptr, "ns:getConferenceIDs");
	case SOAP_TYPE_ns__removeChair:
		return soap_out_ns__removeChair(soap, tag, id, (const struct ns__removeChair *)ptr, "ns:removeChair");
	case SOAP_TYPE_ns__removeChairResponse:
		return soap_out_ns__removeChairResponse(soap, tag, id, (const struct ns__removeChairResponse *)ptr, "ns:removeChairResponse");
	case SOAP_TYPE_ns__setChair:
		return soap_out_ns__setChair(soap, tag, id, (const struct ns__setChair *)ptr, "ns:setChair");
	case SOAP_TYPE_ns__setChairResponse:
		return soap_out_ns__setChairResponse(soap, tag, id, (const struct ns__setChairResponse *)ptr, "ns:setChairResponse");
	case SOAP_TYPE_ns__removeUser:
		return soap_out_ns__removeUser(soap, tag, id, (const struct ns__removeUser *)ptr, "ns:removeUser");
	case SOAP_TYPE_ns__removeUserResponse:
		return soap_out_ns__removeUserResponse(soap, tag, id, (const struct ns__removeUserResponse *)ptr, "ns:removeUserResponse");
	case SOAP_TYPE_ns__addUser:
		return soap_out_ns__addUser(soap, tag, id, (const struct ns__addUser *)ptr, "ns:addUser");
	case SOAP_TYPE_ns__addUserResponse:
		return soap_out_ns__addUserResponse(soap, tag, id, (const struct ns__addUserResponse *)ptr, "ns:addUserResponse");
	case SOAP_TYPE_ns__modifyFloor:
		return soap_out_ns__modifyFloor(soap, tag, id, (const struct ns__modifyFloor *)ptr, "ns:modifyFloor");
	case SOAP_TYPE_ns__modifyFloorResponse:
		return soap_out_ns__modifyFloorResponse(soap, tag, id, (const struct ns__modifyFloorResponse *)ptr, "ns:modifyFloorResponse");
	case SOAP_TYPE_ns__removeFloor:
		return soap_out_ns__removeFloor(soap, tag, id, (const struct ns__removeFloor *)ptr, "ns:removeFloor");
	case SOAP_TYPE_ns__removeFloorResponse:
		return soap_out_ns__removeFloorResponse(soap, tag, id, (const struct ns__removeFloorResponse *)ptr, "ns:removeFloorResponse");
	case SOAP_TYPE_ns__addFloor:
		return soap_out_ns__addFloor(soap, tag, id, (const struct ns__addFloor *)ptr, "ns:addFloor");
	case SOAP_TYPE_ns__addFloorResponse:
		return soap_out_ns__addFloorResponse(soap, tag, id, (const struct ns__addFloorResponse *)ptr, "ns:addFloorResponse");
	case SOAP_TYPE_ns__modifyConference:
		return soap_out_ns__modifyConference(soap, tag, id, (const struct ns__modifyConference *)ptr, "ns:modifyConference");
	case SOAP_TYPE_ns__modifyConferenceResponse:
		return soap_out_ns__modifyConferenceResponse(soap, tag, id, (const struct ns__modifyConferenceResponse *)ptr, "ns:modifyConferenceResponse");
	case SOAP_TYPE_ns__removeConference:
		return soap_out_ns__removeConference(soap, tag, id, (const struct ns__removeConference *)ptr, "ns:removeConference");
	case SOAP_TYPE_ns__removeConferenceResponse:
		return soap_out_ns__removeConferenceResponse(soap, tag, id, (const struct ns__removeConferenceResponse *)ptr, "ns:removeConferenceResponse");
	case SOAP_TYPE_ns__addConference:
		return soap_out_ns__addConference(soap, tag, id, (const struct ns__addConference *)ptr, "ns:addConference");
	case SOAP_TYPE_ns__addConferenceResponse:
		return soap_out_ns__addConferenceResponse(soap, tag, id, (const struct ns__addConferenceResponse *)ptr, "ns:addConferenceResponse");
	case SOAP_TYPE_ns__quit:
		return soap_out_ns__quit(soap, tag, id, (const struct ns__quit *)ptr, "ns:quit");
	case SOAP_TYPE_ns__stop:
		return soap_out_ns__stop(soap, tag, id, (const struct ns__stop *)ptr, "ns:stop");
	case SOAP_TYPE_ns__stopResponse:
		return soap_out_ns__stopResponse(soap, tag, id, (const struct ns__stopResponse *)ptr, "ns:stopResponse");
	case SOAP_TYPE_ns__start:
		return soap_out_ns__start(soap, tag, id, (const struct ns__start *)ptr, "ns:start");
	case SOAP_TYPE_ns__startResponse:
		return soap_out_ns__startResponse(soap, tag, id, (const struct ns__startResponse *)ptr, "ns:startResponse");
	case SOAP_TYPE_PointerTons__ConferenceInfoResult:
		return soap_out_PointerTons__ConferenceInfoResult(soap, tag, id, (ns__ConferenceInfoResult *const*)ptr, "ns:ConferenceInfoResult");
	case SOAP_TYPE_PointerTons__ConferenceListResult:
		return soap_out_PointerTons__ConferenceListResult(soap, tag, id, (ns__ConferenceListResult *const*)ptr, "ns:ConferenceListResult");
	case SOAP_TYPE_PointerTons__ErrorCode:
		return soap_out_PointerTons__ErrorCode(soap, tag, id, (enum ns__ErrorCode *const*)ptr, "ns:ErrorCode");
	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");
	}
	return SOAP_OK;
}

#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_ns__ConferenceInfoResult:
		((ns__ConferenceInfoResult *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE_ns__ConferenceListResult:
		((ns__ConferenceListResult *)ptr)->soap_serialize(soap);
		break;
	case SOAP_TYPE_xsd__string:
		soap_serialize_xsd__string(soap, (const std::string *)ptr);
		break;
	case SOAP_TYPE_std__string:
		soap_serialize_std__string(soap, (const std::string *)ptr);
		break;
	case SOAP_TYPE_ns__getConferenceInfo:
		soap_serialize_ns__getConferenceInfo(soap, (const struct ns__getConferenceInfo *)ptr);
		break;
	case SOAP_TYPE_ns__getConferenceIDs:
		soap_serialize_ns__getConferenceIDs(soap, (const struct ns__getConferenceIDs *)ptr);
		break;
	case SOAP_TYPE_ns__removeChair:
		soap_serialize_ns__removeChair(soap, (const struct ns__removeChair *)ptr);
		break;
	case SOAP_TYPE_ns__removeChairResponse:
		soap_serialize_ns__removeChairResponse(soap, (const struct ns__removeChairResponse *)ptr);
		break;
	case SOAP_TYPE_ns__setChair:
		soap_serialize_ns__setChair(soap, (const struct ns__setChair *)ptr);
		break;
	case SOAP_TYPE_ns__setChairResponse:
		soap_serialize_ns__setChairResponse(soap, (const struct ns__setChairResponse *)ptr);
		break;
	case SOAP_TYPE_ns__removeUser:
		soap_serialize_ns__removeUser(soap, (const struct ns__removeUser *)ptr);
		break;
	case SOAP_TYPE_ns__removeUserResponse:
		soap_serialize_ns__removeUserResponse(soap, (const struct ns__removeUserResponse *)ptr);
		break;
	case SOAP_TYPE_ns__addUser:
		soap_serialize_ns__addUser(soap, (const struct ns__addUser *)ptr);
		break;
	case SOAP_TYPE_ns__addUserResponse:
		soap_serialize_ns__addUserResponse(soap, (const struct ns__addUserResponse *)ptr);
		break;
	case SOAP_TYPE_ns__modifyFloor:
		soap_serialize_ns__modifyFloor(soap, (const struct ns__modifyFloor *)ptr);
		break;
	case SOAP_TYPE_ns__modifyFloorResponse:
		soap_serialize_ns__modifyFloorResponse(soap, (const struct ns__modifyFloorResponse *)ptr);
		break;
	case SOAP_TYPE_ns__removeFloor:
		soap_serialize_ns__removeFloor(soap, (const struct ns__removeFloor *)ptr);
		break;
	case SOAP_TYPE_ns__removeFloorResponse:
		soap_serialize_ns__removeFloorResponse(soap, (const struct ns__removeFloorResponse *)ptr);
		break;
	case SOAP_TYPE_ns__addFloor:
		soap_serialize_ns__addFloor(soap, (const struct ns__addFloor *)ptr);
		break;
	case SOAP_TYPE_ns__addFloorResponse:
		soap_serialize_ns__addFloorResponse(soap, (const struct ns__addFloorResponse *)ptr);
		break;
	case SOAP_TYPE_ns__modifyConference:
		soap_serialize_ns__modifyConference(soap, (const struct ns__modifyConference *)ptr);
		break;
	case SOAP_TYPE_ns__modifyConferenceResponse:
		soap_serialize_ns__modifyConferenceResponse(soap, (const struct ns__modifyConferenceResponse *)ptr);
		break;
	case SOAP_TYPE_ns__removeConference:
		soap_serialize_ns__removeConference(soap, (const struct ns__removeConference *)ptr);
		break;
	case SOAP_TYPE_ns__removeConferenceResponse:
		soap_serialize_ns__removeConferenceResponse(soap, (const struct ns__removeConferenceResponse *)ptr);
		break;
	case SOAP_TYPE_ns__addConference:
		soap_serialize_ns__addConference(soap, (const struct ns__addConference *)ptr);
		break;
	case SOAP_TYPE_ns__addConferenceResponse:
		soap_serialize_ns__addConferenceResponse(soap, (const struct ns__addConferenceResponse *)ptr);
		break;
	case SOAP_TYPE_ns__quit:
		soap_serialize_ns__quit(soap, (const struct ns__quit *)ptr);
		break;
	case SOAP_TYPE_ns__stop:
		soap_serialize_ns__stop(soap, (const struct ns__stop *)ptr);
		break;
	case SOAP_TYPE_ns__stopResponse:
		soap_serialize_ns__stopResponse(soap, (const struct ns__stopResponse *)ptr);
		break;
	case SOAP_TYPE_ns__start:
		soap_serialize_ns__start(soap, (const struct ns__start *)ptr);
		break;
	case SOAP_TYPE_ns__startResponse:
		soap_serialize_ns__startResponse(soap, (const struct ns__startResponse *)ptr);
		break;
	case SOAP_TYPE_PointerTons__ConferenceInfoResult:
		soap_serialize_PointerTons__ConferenceInfoResult(soap, (ns__ConferenceInfoResult *const*)ptr);
		break;
	case SOAP_TYPE_PointerTons__ConferenceListResult:
		soap_serialize_PointerTons__ConferenceListResult(soap, (ns__ConferenceListResult *const*)ptr);
		break;
	case SOAP_TYPE_PointerTons__ErrorCode:
		soap_serialize_PointerTons__ErrorCode(soap, (enum ns__ErrorCode *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

SOAP_FMAC3 void * SOAP_FMAC4 soap_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*)soap_instantiate_std__string(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__ConferenceListResult:
		return (void*)soap_instantiate_ns__ConferenceListResult(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__ConferenceInfoResult:
		return (void*)soap_instantiate_ns__ConferenceInfoResult(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__startResponse:
		return (void*)soap_instantiate_ns__startResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__start:
		return (void*)soap_instantiate_ns__start(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__stopResponse:
		return (void*)soap_instantiate_ns__stopResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__stop:
		return (void*)soap_instantiate_ns__stop(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__quit:
		return (void*)soap_instantiate_ns__quit(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addConferenceResponse:
		return (void*)soap_instantiate_ns__addConferenceResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addConference:
		return (void*)soap_instantiate_ns__addConference(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeConferenceResponse:
		return (void*)soap_instantiate_ns__removeConferenceResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeConference:
		return (void*)soap_instantiate_ns__removeConference(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__modifyConferenceResponse:
		return (void*)soap_instantiate_ns__modifyConferenceResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__modifyConference:
		return (void*)soap_instantiate_ns__modifyConference(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addFloorResponse:
		return (void*)soap_instantiate_ns__addFloorResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addFloor:
		return (void*)soap_instantiate_ns__addFloor(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeFloorResponse:
		return (void*)soap_instantiate_ns__removeFloorResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeFloor:
		return (void*)soap_instantiate_ns__removeFloor(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__modifyFloorResponse:
		return (void*)soap_instantiate_ns__modifyFloorResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__modifyFloor:
		return (void*)soap_instantiate_ns__modifyFloor(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addUserResponse:
		return (void*)soap_instantiate_ns__addUserResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__addUser:
		return (void*)soap_instantiate_ns__addUser(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeUserResponse:
		return (void*)soap_instantiate_ns__removeUserResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeUser:
		return (void*)soap_instantiate_ns__removeUser(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__setChairResponse:
		return (void*)soap_instantiate_ns__setChairResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__setChair:
		return (void*)soap_instantiate_ns__setChair(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeChairResponse:
		return (void*)soap_instantiate_ns__removeChairResponse(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__removeChair:
		return (void*)soap_instantiate_ns__removeChair(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__getConferenceIDs:
		return (void*)soap_instantiate_ns__getConferenceIDs(soap, -1, type, arrayType, n);
	case SOAP_TYPE_ns__getConferenceInfo:
		return (void*)soap_instantiate_ns__getConferenceInfo(soap, -1, type, arrayType, n);
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Header:
		return (void*)soap_instantiate_SOAP_ENV__Header(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Code:
		return (void*)soap_instantiate_SOAP_ENV__Code(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Detail:
		return (void*)soap_instantiate_SOAP_ENV__Detail(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Reason:
		return (void*)soap_instantiate_SOAP_ENV__Reason(soap, -1, type, arrayType, n);
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Fault:
		return (void*)soap_instantiate_SOAP_ENV__Fault(soap, -1, type, arrayType, n);
#endif
	case SOAP_TYPE_xsd__string:
		return (void*)soap_instantiate_xsd__string(soap, -1, type, arrayType, n);
	case SOAP_TYPE_std__vectorTemplateOfunsignedInt:
		return (void*)soap_instantiate_std__vectorTemplateOfunsignedInt(soap, -1, type, arrayType, n);
	}
	return NULL;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap_clist *p)
{	switch (p->type)
	{
	case SOAP_TYPE_std__string:
		if (p->size < 0)
			SOAP_DELETE((std::string*)p->ptr);
		else
			SOAP_DELETE_ARRAY((std::string*)p->ptr);
		break;
	case SOAP_TYPE_ns__ConferenceListResult:
		if (p->size < 0)
			SOAP_DELETE((ns__ConferenceListResult*)p->ptr);
		else
			SOAP_DELETE_ARRAY((ns__ConferenceListResult*)p->ptr);
		break;
	case SOAP_TYPE_ns__ConferenceInfoResult:
		if (p->size < 0)
			SOAP_DELETE((ns__ConferenceInfoResult*)p->ptr);
		else
			SOAP_DELETE_ARRAY((ns__ConferenceInfoResult*)p->ptr);
		break;
	case SOAP_TYPE_ns__startResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__startResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__startResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__start:
		if (p->size < 0)
			SOAP_DELETE((struct ns__start*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__start*)p->ptr);
		break;
	case SOAP_TYPE_ns__stopResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__stopResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__stopResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__stop:
		if (p->size < 0)
			SOAP_DELETE((struct ns__stop*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__stop*)p->ptr);
		break;
	case SOAP_TYPE_ns__quit:
		if (p->size < 0)
			SOAP_DELETE((struct ns__quit*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__quit*)p->ptr);
		break;
	case SOAP_TYPE_ns__addConferenceResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addConferenceResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addConferenceResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__addConference:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addConference*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addConference*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeConferenceResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeConferenceResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeConferenceResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeConference:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeConference*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeConference*)p->ptr);
		break;
	case SOAP_TYPE_ns__modifyConferenceResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__modifyConferenceResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__modifyConferenceResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__modifyConference:
		if (p->size < 0)
			SOAP_DELETE((struct ns__modifyConference*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__modifyConference*)p->ptr);
		break;
	case SOAP_TYPE_ns__addFloorResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addFloorResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addFloorResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__addFloor:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addFloor*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addFloor*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeFloorResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeFloorResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeFloorResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeFloor:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeFloor*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeFloor*)p->ptr);
		break;
	case SOAP_TYPE_ns__modifyFloorResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__modifyFloorResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__modifyFloorResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__modifyFloor:
		if (p->size < 0)
			SOAP_DELETE((struct ns__modifyFloor*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__modifyFloor*)p->ptr);
		break;
	case SOAP_TYPE_ns__addUserResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addUserResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addUserResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__addUser:
		if (p->size < 0)
			SOAP_DELETE((struct ns__addUser*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__addUser*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeUserResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeUserResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeUserResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeUser:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeUser*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeUser*)p->ptr);
		break;
	case SOAP_TYPE_ns__setChairResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__setChairResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__setChairResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__setChair:
		if (p->size < 0)
			SOAP_DELETE((struct ns__setChair*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__setChair*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeChairResponse:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeChairResponse*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeChairResponse*)p->ptr);
		break;
	case SOAP_TYPE_ns__removeChair:
		if (p->size < 0)
			SOAP_DELETE((struct ns__removeChair*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__removeChair*)p->ptr);
		break;
	case SOAP_TYPE_ns__getConferenceIDs:
		if (p->size < 0)
			SOAP_DELETE((struct ns__getConferenceIDs*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__getConferenceIDs*)p->ptr);
		break;
	case SOAP_TYPE_ns__getConferenceInfo:
		if (p->size < 0)
			SOAP_DELETE((struct ns__getConferenceInfo*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct ns__getConferenceInfo*)p->ptr);
		break;
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Header:
		if (p->size < 0)
			SOAP_DELETE((struct SOAP_ENV__Header*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct SOAP_ENV__Header*)p->ptr);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Code:
		if (p->size < 0)
			SOAP_DELETE((struct SOAP_ENV__Code*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct SOAP_ENV__Code*)p->ptr);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Detail:
		if (p->size < 0)
			SOAP_DELETE((struct SOAP_ENV__Detail*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct SOAP_ENV__Detail*)p->ptr);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Reason:
		if (p->size < 0)
			SOAP_DELETE((struct SOAP_ENV__Reason*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct SOAP_ENV__Reason*)p->ptr);
		break;
#endif
#ifndef WITH_NOGLOBAL
	case SOAP_TYPE_SOAP_ENV__Fault:
		if (p->size < 0)
			SOAP_DELETE((struct SOAP_ENV__Fault*)p->ptr);
		else
			SOAP_DELETE_ARRAY((struct SOAP_ENV__Fault*)p->ptr);
		break;
#endif
	case SOAP_TYPE_xsd__string:
		if (p->size < 0)
			SOAP_DELETE((std::string*)p->ptr);
		else
			SOAP_DELETE_ARRAY((std::string*)p->ptr);
		break;
	case SOAP_TYPE_std__vectorTemplateOfunsignedInt:
		if (p->size < 0)
			SOAP_DELETE((std::vector<unsigned int >*)p->ptr);
		else
			SOAP_DELETE_ARRAY((std::vector<unsigned int >*)p->ptr);
		break;
	default:	return SOAP_ERR;
	}
	return SOAP_OK;
}

SOAP_FMAC3 void* SOAP_FMAC4 soap_class_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, const char *type, const char *arrayType)
{	return soap_id_enter(soap, id, p, t, n, 0, type, arrayType, soap_instantiate);
}

SOAP_FMAC3 void* SOAP_FMAC4 soap_container_id_forward(struct soap *soap, const char *href, void *p, size_t len, int st, int tt, size_t n, unsigned int k)
{	return soap_id_forward(soap, href, p, len, st, tt, n, k, soap_container_insert);
}

SOAP_FMAC3 void SOAP_FMAC4 soap_container_insert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable:4065)
#endif
{
	(void)soap; (void)st; (void)p; (void)len; (void)q; (void)n; /* appease -Wall -Werror */
	switch (tt)
	{
	case SOAP_TYPE_std__vectorTemplateOfunsignedInt:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container soap_container_insert type = %d in %d location = %p object = %p len = %lu\n", st, tt, p, q, (unsigned long)len));
		(*(std::vector<unsigned int >*)p)[len] = *(unsigned int *)q;
		break;
	default:
		DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not insert type = %d in %d\n", st, tt));
	}
#ifdef WIN32
#pragma warning(pop)
#endif
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_byte
	*a = SOAP_DEFAULT_byte;
#else
	*a = (char)0;
#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)
{	char *p;
	p = soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_byte);
	if (soap_out_byte(soap, tag?tag:"byte", id, 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 void SOAP_FMAC4 soap_default_short(struct soap *soap, short *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_short
	*a = SOAP_DEFAULT_short;
#else
	*a = (short)0;
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_short(struct soap *soap, const char *tag, int id, const short *a, const char *type)
{
	return soap_outshort(soap, tag, id, a, type, SOAP_TYPE_short);
}

SOAP_FMAC3 short * SOAP_FMAC4 soap_in_short(struct soap *soap, const char *tag, short *a, const char *type)
{	short *p;
	p = soap_inshort(soap, tag, a, type, SOAP_TYPE_short);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_short(struct soap *soap, const short *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_short);
	if (soap_out_short(soap, tag?tag:"short", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_int
	*a = SOAP_DEFAULT_int;
#else
	*a = (int)0;
#endif
}

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)
{	int *p;
	p = soap_inint(soap, tag, a, type, SOAP_TYPE_int);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_int);
	if (soap_out_int(soap, tag?tag:"int", id, 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_default_double(struct soap *soap, double *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_double
	*a = SOAP_DEFAULT_double;
#else
	*a = (double)0;
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_double(struct soap *soap, const char *tag, int id, const double *a, const char *type)
{
	return soap_outdouble(soap, tag, id, a, type, SOAP_TYPE_double);
}

SOAP_FMAC3 double * SOAP_FMAC4 soap_in_double(struct soap *soap, const char *tag, double *a, const char *type)
{	double *p;
	p = soap_indouble(soap, tag, a, type, SOAP_TYPE_double);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_double(struct soap *soap, const double *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_double);
	if (soap_out_double(soap, tag?tag:"double", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedShort(struct soap *soap, unsigned short *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_unsignedShort
	*a = SOAP_DEFAULT_unsignedShort;
#else
	*a = (unsigned short)0;
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type)
{
	return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_unsignedShort);
}

SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_unsignedShort(struct soap *soap, const char *tag, unsigned short *a, const char *type)
{	unsigned short *p;
	p = soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_unsignedShort);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedShort(struct soap *soap, const unsigned short *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_unsignedShort);
	if (soap_out_unsignedShort(soap, tag?tag:"unsignedShort", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_unsignedShort(struct soap *soap, unsigned short *p, const char *tag, const char *type)
{
	if ((p = soap_in_unsignedShort(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedInt(struct soap *soap, unsigned int *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_unsignedInt
	*a = SOAP_DEFAULT_unsignedInt;
#else
	*a = (unsigned int)0;
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type)
{
	return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_unsignedInt);
}

SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap *soap, const char *tag, unsigned int *a, const char *type)
{	unsigned int *p;
	p = soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_unsignedInt);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap *soap, const unsigned int *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_unsignedInt);
	if (soap_out_unsignedInt(soap, tag?tag:"unsignedInt", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_default_bool(struct soap *soap, bool *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_bool
	*a = SOAP_DEFAULT_bool;
#else
	*a = (bool)0;
#endif
}

static const struct soap_code_map soap_codes_bool[] =
{	{ (long)false, "false" },
	{ (long)true, "true" },
	{ 0, NULL }
};

SOAP_FMAC3S const char* SOAP_FMAC4S soap_bool2s(struct soap *soap, bool n)
{
	(void)soap; /* appease -Wall -Werror */
return soap_code_str(soap_codes_bool, n != 0);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_bool(struct soap *soap, const char *tag, int id, const bool *a, const char *type)
{	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_bool), type) || soap_send(soap, soap_bool2s(soap, *a)))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3S int SOAP_FMAC4S soap_s2bool(struct soap *soap, const char *s, bool *a)
{
	const struct soap_code_map *map;
	if (!s)
		return soap->error;
	map = soap_code(soap_codes_bool, s);
	if (map)
		*a = (bool)(map->code != 0);
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || n < 0 || n > 1)
			return soap->error = SOAP_TYPE;
		*a = (bool)(n != 0);
	}
	return SOAP_OK;
}

SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_bool(struct soap *soap, const char *tag, bool *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":boolean"))
	{	soap->error = SOAP_TYPE;
		return NULL;
	}
	a = (bool *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_bool, sizeof(bool), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	if (soap->body && !*soap->href)
	{	if (!a || soap_s2bool(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (bool *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_bool, 0, sizeof(bool), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_bool(struct soap *soap, const bool *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_bool);
	if (soap_out_bool(soap, tag?tag:"boolean", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__AddrFamily(struct soap *soap, enum ns__AddrFamily *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_ns__AddrFamily
	*a = SOAP_DEFAULT_ns__AddrFamily;
#else
	*a = (enum ns__AddrFamily)0;
#endif
}

static const struct soap_code_map soap_codes_ns__AddrFamily[] =
{	{ (long)kIPv4, "kIPv4" },
	{ (long)kIPv6, "kIPv6" },
	{ 0, NULL }
};

SOAP_FMAC3S const char* SOAP_FMAC4S soap_ns__AddrFamily2s(struct soap *soap, enum ns__AddrFamily n)
{	const char *s = soap_code_str(soap_codes_ns__AddrFamily, (long)n);
	if (s)
		return s;
	return soap_long2s(soap, (long)n);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__AddrFamily(struct soap *soap, const char *tag, int id, const enum ns__AddrFamily *a, const char *type)
{	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns__AddrFamily), type) || soap_send(soap, soap_ns__AddrFamily2s(soap, *a)))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3S int SOAP_FMAC4S soap_s2ns__AddrFamily(struct soap *soap, const char *s, enum ns__AddrFamily *a)
{
	const struct soap_code_map *map;
	if (!s)
		return soap->error;
	map = soap_code(soap_codes_ns__AddrFamily, s);
	if (map)
		*a = (enum ns__AddrFamily)map->code;
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1)))
			return soap->error = SOAP_TYPE;
		*a = (enum ns__AddrFamily)n;
	}
	return SOAP_OK;
}

SOAP_FMAC3 enum ns__AddrFamily * SOAP_FMAC4 soap_in_ns__AddrFamily(struct soap *soap, const char *tag, enum ns__AddrFamily *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (enum ns__AddrFamily *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__AddrFamily, sizeof(enum ns__AddrFamily), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	if (soap->body && !*soap->href)
	{	if (!a || soap_s2ns__AddrFamily(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (enum ns__AddrFamily *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__AddrFamily, 0, sizeof(enum ns__AddrFamily), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__AddrFamily(struct soap *soap, const enum ns__AddrFamily *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__AddrFamily);
	if (soap_out_ns__AddrFamily(soap, tag?tag:"ns:AddrFamily", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 enum ns__AddrFamily * SOAP_FMAC4 soap_get_ns__AddrFamily(struct soap *soap, enum ns__AddrFamily *p, const char *tag, const char *type)
{
	if ((p = soap_in_ns__AddrFamily(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__Policy(struct soap *soap, enum ns__Policy *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_ns__Policy
	*a = SOAP_DEFAULT_ns__Policy;
#else
	*a = (enum ns__Policy)0;
#endif
}

static const struct soap_code_map soap_codes_ns__Policy[] =
{	{ (long)kAutoAccept, "kAutoAccept" },
	{ (long)kAutoDeny, "kAutoDeny" },
	{ 0, NULL }
};

SOAP_FMAC3S const char* SOAP_FMAC4S soap_ns__Policy2s(struct soap *soap, enum ns__Policy n)
{	const char *s = soap_code_str(soap_codes_ns__Policy, (long)n);
	if (s)
		return s;
	return soap_long2s(soap, (long)n);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__Policy(struct soap *soap, const char *tag, int id, const enum ns__Policy *a, const char *type)
{	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns__Policy), type) || soap_send(soap, soap_ns__Policy2s(soap, *a)))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3S int SOAP_FMAC4S soap_s2ns__Policy(struct soap *soap, const char *s, enum ns__Policy *a)
{
	const struct soap_code_map *map;
	if (!s)
		return soap->error;
	map = soap_code(soap_codes_ns__Policy, s);
	if (map)
		*a = (enum ns__Policy)map->code;
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1)))
			return soap->error = SOAP_TYPE;
		*a = (enum ns__Policy)n;
	}
	return SOAP_OK;
}

SOAP_FMAC3 enum ns__Policy * SOAP_FMAC4 soap_in_ns__Policy(struct soap *soap, const char *tag, enum ns__Policy *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (enum ns__Policy *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__Policy, sizeof(enum ns__Policy), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	if (soap->body && !*soap->href)
	{	if (!a || soap_s2ns__Policy(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (enum ns__Policy *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__Policy, 0, sizeof(enum ns__Policy), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__Policy(struct soap *soap, const enum ns__Policy *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__Policy);
	if (soap_out_ns__Policy(soap, tag?tag:"ns:Policy", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 enum ns__Policy * SOAP_FMAC4 soap_get_ns__Policy(struct soap *soap, enum ns__Policy *p, const char *tag, const char *type)
{
	if ((p = soap_in_ns__Policy(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__ErrorCode(struct soap *soap, enum ns__ErrorCode *a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_ns__ErrorCode
	*a = SOAP_DEFAULT_ns__ErrorCode;
#else
	*a = (enum ns__ErrorCode)0;
#endif
}

static const struct soap_code_map soap_codes_ns__ErrorCode[] =
{	{ (long)kNoError, "kNoError" },
	{ (long)kUserNotExist, "kUserNotExist" },
	{ (long)kUserAlreadyExist, "kUserAlreadyExist" },
	{ (long)kFloorNotExist, "kFloorNotExist" },
	{ (long)kFloorAlreadyExist, "kFloorAlreadyExist" },
	{ (long)kChairNotExost, "kChairNotExost" },
	{ (long)kChairAlreadyExist, "kChairAlreadyExist" },
	{ (long)kConferenceNotExist, "kConferenceNotExist" },
	{ (long)kConferenceAlreadyExist, "kConferenceAlreadyExist" },
	{ (long)kServerNotStart, "kServerNotStart" },
	{ (long)kServerAlreadyStart, "kServerAlreadyStart" },
	{ 0, NULL }
};

SOAP_FMAC3S const char* SOAP_FMAC4S soap_ns__ErrorCode2s(struct soap *soap, enum ns__ErrorCode n)
{	const char *s = soap_code_str(soap_codes_ns__ErrorCode, (long)n);
	if (s)
		return s;
	return soap_long2s(soap, (long)n);
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__ErrorCode(struct soap *soap, const char *tag, int id, const enum ns__ErrorCode *a, const char *type)
{	if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_ns__ErrorCode), type) || soap_send(soap, soap_ns__ErrorCode2s(soap, *a)))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3S int SOAP_FMAC4S soap_s2ns__ErrorCode(struct soap *soap, const char *s, enum ns__ErrorCode *a)
{
	const struct soap_code_map *map;
	if (!s)
		return soap->error;
	map = soap_code(soap_codes_ns__ErrorCode, s);
	if (map)
		*a = (enum ns__ErrorCode)map->code;
	else
	{	long n;
		if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 10)))
			return soap->error = SOAP_TYPE;
		*a = (enum ns__ErrorCode)n;
	}
	return SOAP_OK;
}

SOAP_FMAC3 enum ns__ErrorCode * SOAP_FMAC4 soap_in_ns__ErrorCode(struct soap *soap, const char *tag, enum ns__ErrorCode *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (enum ns__ErrorCode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__ErrorCode, sizeof(enum ns__ErrorCode), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	if (soap->body && !*soap->href)
	{	if (!a || soap_s2ns__ErrorCode(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
			return NULL;
	}
	else
	{	a = (enum ns__ErrorCode *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__ErrorCode, 0, sizeof(enum ns__ErrorCode), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__ErrorCode(struct soap *soap, const enum ns__ErrorCode *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__ErrorCode);
	if (soap_out_ns__ErrorCode(soap, tag?tag:"ns:ErrorCode", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 enum ns__ErrorCode * SOAP_FMAC4 soap_get_ns__ErrorCode(struct soap *soap, enum ns__ErrorCode *p, const char *tag, const char *type)
{
	if ((p = soap_in_ns__ErrorCode(soap, tag, p, type)))
		if (soap_getindependent(soap))
			return NULL;
	return p;
}

void ns__ConferenceInfoResult::soap_default(struct soap *soap)
{
	(void)soap; /* appease -Wall -Werror */
	soap_default_ns__ErrorCode(soap, &this->ns__ConferenceInfoResult::errorCode);
	soap_default_xsd__string(soap, &this->ns__ConferenceInfoResult::conferenceInfo);
}

void ns__ConferenceInfoResult::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_embedded(soap, &this->ns__ConferenceInfoResult::errorCode, SOAP_TYPE_ns__ErrorCode);
	soap_serialize_xsd__string(soap, &this->ns__ConferenceInfoResult::conferenceInfo);
#endif
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__ConferenceInfoResult(struct soap *soap, const char *tag, int id, const ns__ConferenceInfoResult *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_ns__ConferenceInfoResult), type))
		return soap->error;
	if (soap_out_ns__ErrorCode(soap, "errorCode", -1, &(a->ns__ConferenceInfoResult::errorCode), ""))
		return soap->error;
	if (soap_out_xsd__string(soap, "conferenceInfo", -1, &(a->ns__ConferenceInfoResult::conferenceInfo), ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

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

SOAP_FMAC3 ns__ConferenceInfoResult * SOAP_FMAC4 soap_in_ns__ConferenceInfoResult(struct soap *soap, const char *tag, ns__ConferenceInfoResult *a, const char *type)
{
	(void)tag; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (ns__ConferenceInfoResult *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_ns__ConferenceInfoResult, sizeof(ns__ConferenceInfoResult), soap->type, soap->arrayType);
	if (!a)
		return NULL;
	if (soap->alloced)
	{	a->soap_default(soap);
		if (soap->clist->type != SOAP_TYPE_ns__ConferenceInfoResult)
		{	soap_revert(soap);
			*soap->id = '\0';
			return (ns__ConferenceInfoResult *)a->soap_in(soap, tag, type);
		}
	}
	size_t soap_flag_errorCode1 = 1;
	size_t soap_flag_conferenceInfo1 = 1;
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode1 && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_ns__ErrorCode(soap, "errorCode", &(a->ns__ConferenceInfoResult::errorCode), "ns:ErrorCode"))
				{	soap_flag_errorCode1--;
					continue;
				}
			if (soap_flag_conferenceInfo1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
				if (soap_in_xsd__string(soap, "conferenceInfo", &(a->ns__ConferenceInfoResult::conferenceInfo), "xsd:string"))
				{	soap_flag_conferenceInfo1--;
					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 = (ns__ConferenceInfoResult *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__ConferenceInfoResult, 0, sizeof(ns__ConferenceInfoResult), 0, soap_copy_ns__ConferenceInfoResult);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_errorCode1 > 0 || soap_flag_conferenceInfo1 > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

int ns__ConferenceInfoResult::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	register int id = soap_embed(soap, (void*)this, NULL, 0, SOAP_TYPE_ns__ConferenceInfoResult);
	if (this->soap_out(soap, tag?tag:"ns:ConferenceInfoResult", id, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__ConferenceInfoResult(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying ns__ConferenceInfoResult %p -> %p\n", q, p));
	*(ns__ConferenceInfoResult*)p = *(ns__ConferenceInfoResult*)q;
}

void ns__ConferenceListResult::soap_default(struct soap *soap)
{
	(void)soap; /* appease -Wall -Werror */
	soap_default_ns__ErrorCode(soap, &this->ns__ConferenceListResult::errorCode);
	soap_default_std__vectorTemplateOfunsignedInt(soap, &this->ns__ConferenceListResult::conferenceIDs);
}

void ns__ConferenceListResult::soap_serialize(struct soap *soap) const
{
	(void)soap; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_embedded(soap, &this->ns__ConferenceListResult::errorCode, SOAP_TYPE_ns__ErrorCode);
	soap_serialize_std__vectorTemplateOfunsignedInt(soap, &this->ns__ConferenceListResult::conferenceIDs);
#endif
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__ConferenceListResult(struct soap *soap, const char *tag, int id, const ns__ConferenceListResult *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_ns__ConferenceListResult), type))
		return soap->error;
	if (soap_out_ns__ErrorCode(soap, "errorCode", -1, &(a->ns__ConferenceListResult::errorCode), ""))
		return soap->error;
	if (soap_out_std__vectorTemplateOfunsignedInt(soap, "conferenceIDs", -1, &(a->ns__ConferenceListResult::conferenceIDs), ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

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

SOAP_FMAC3 ns__ConferenceListResult * SOAP_FMAC4 soap_in_ns__ConferenceListResult(struct soap *soap, const char *tag, ns__ConferenceListResult *a, const char *type)
{
	(void)tag; (void)type; /* appease -Wall -Werror */
	if (soap_element_begin_in(soap, tag, 0, NULL))
		return NULL;
	a = (ns__ConferenceListResult *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_ns__ConferenceListResult, sizeof(ns__ConferenceListResult), soap->type, soap->arrayType);
	if (!a)
		return NULL;
	if (soap->alloced)
	{	a->soap_default(soap);
		if (soap->clist->type != SOAP_TYPE_ns__ConferenceListResult)
		{	soap_revert(soap);
			*soap->id = '\0';
			return (ns__ConferenceListResult *)a->soap_in(soap, tag, type);
		}
	}
	size_t soap_flag_errorCode1 = 1;
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode1 && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_ns__ErrorCode(soap, "errorCode", &(a->ns__ConferenceListResult::errorCode), "ns:ErrorCode"))
				{	soap_flag_errorCode1--;
					continue;
				}
			if (soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_std__vectorTemplateOfunsignedInt(soap, "conferenceIDs", &(a->ns__ConferenceListResult::conferenceIDs), "xsd:unsignedInt"))
					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 = (ns__ConferenceListResult *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__ConferenceListResult, 0, sizeof(ns__ConferenceListResult), 0, soap_copy_ns__ConferenceListResult);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_errorCode1 > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

int ns__ConferenceListResult::soap_put(struct soap *soap, const char *tag, const  char *type) const
{
	register int id = soap_embed(soap, (void*)this, NULL, 0, SOAP_TYPE_ns__ConferenceListResult);
	if (this->soap_out(soap, tag?tag:"ns:ConferenceListResult", id, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__ConferenceListResult(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying ns__ConferenceListResult %p -> %p\n", q, p));
	*(ns__ConferenceListResult*)p = *(ns__ConferenceListResult*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__string(struct soap *soap, const std::string *a)
{	(void)soap; (void)a; /* appease -Wall -Werror */
}
SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__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_xsd__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_xsd__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_class_id_enter(soap, soap->id, s, SOAP_TYPE_xsd__string, sizeof(std::string), soap->type, soap->arrayType);
		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_class_id_enter(soap, soap->id, s, SOAP_TYPE_xsd__string, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_xsd__string, 0, sizeof(std::string), 0, soap_copy_xsd__string);
	if (soap->body && soap_element_end_in(soap, tag))
		return NULL;
	return s;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__string(struct soap *soap, const std::string *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_xsd__string);
	if (soap_out_xsd__string(soap, tag?tag:"xsd:string", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__string(struct soap *soap, std::string *p)
{
	(void)soap; /* appease -Wall -Werror */
	p->erase();
}

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_class_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType);
		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_class_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_std__string, 0, sizeof(std::string), 0, soap_copy_std__string);
	if (soap->body && soap_element_end_in(soap, tag))
		return NULL;
	return s;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_std__string(struct soap *soap, const std::string *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_std__string);
	if (soap_out_std__string(soap, tag?tag:"string", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__string(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p));
	*(std::string*)p = *(std::string*)q;
}

#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, &a->faultcode);
	soap_serialize_string(soap, &a->faultstring);
	soap_serialize_string(soap, &a->faultactor);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
	soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
	soap_serialize_string(soap, &a->SOAP_ENV__Node);
	soap_serialize_string(soap, &a->SOAP_ENV__Role);
	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
#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_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, &a->faultstring, ""))
		return soap->error;
	if (soap_out_string(soap, "faultactor", -1, &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, &a->SOAP_ENV__Node, ""))
		return soap->error;
	if (soap_out_string(soap, "SOAP-ENV:Role", -1, &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, type))
		return NULL;
	a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, 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", &a->faultcode, ""))
				{	soap_flag_faultcode--;
					continue;
				}
			if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
				if (soap_in_string(soap, "faultstring", &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", &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", &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", &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, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

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)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_SOAP_ENV__Fault);
	if (soap_out_SOAP_ENV__Fault(soap, tag?tag:"SOAP-ENV:Fault", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Fault(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Fault %p -> %p\n", q, p));
	*(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;
}

#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, &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, &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, type))
		return NULL;
	a = (struct SOAP_ENV__Reason *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, 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", &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, 0, 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_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_SOAP_ENV__Reason);
	if (soap_out_SOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Reason(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Reason %p -> %p\n", q, p));
	*(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;
}

#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;
	soap_outliteral(soap, "-any", &a->__any, NULL);
	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, type))
		return NULL;
	a = (struct SOAP_ENV__Detail *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, 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, &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", &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, 0, 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_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_SOAP_ENV__Detail);
	if (soap_out_SOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Detail(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Detail %p -> %p\n", q, p));
	*(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;
}

#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, &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_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, type))
		return NULL;
	a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, 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", &a->SOAP_ENV__Value, ""))
				{	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, 0, 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_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_SOAP_ENV__Code);
	if (soap_out_SOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Code(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Code %p -> %p\n", q, p));
	*(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;
}

#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, type))
		return NULL;
	a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, 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, 0, sizeof(struct SOAP_ENV__Header), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

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)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_SOAP_ENV__Header);
	if (soap_out_SOAP_ENV__Header(soap, tag?tag:"SOAP-ENV:Header", id, 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;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Header(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Header %p -> %p\n", q, p));
	*(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;
}

#endif

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__getConferenceInfo(struct soap *soap, struct ns__getConferenceInfo *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__getConferenceInfo(struct soap *soap, const char *tag, int id, const struct ns__getConferenceInfo *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_ns__getConferenceInfo), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__getConferenceInfo * SOAP_FMAC4 soap_in_ns__getConferenceInfo(struct soap *soap, const char *tag, struct ns__getConferenceInfo *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__getConferenceInfo *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getConferenceInfo, sizeof(struct ns__getConferenceInfo), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__getConferenceInfo(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					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 ns__getConferenceInfo *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__getConferenceInfo, 0, sizeof(struct ns__getConferenceInfo), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__getConferenceInfo(struct soap *soap, const struct ns__getConferenceInfo *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__getConferenceInfo);
	if (soap_out_ns__getConferenceInfo(soap, tag?tag:"ns:getConferenceInfo", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__getConferenceInfo(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__getConferenceInfo %p -> %p\n", q, p));
	*(struct ns__getConferenceInfo*)p = *(struct ns__getConferenceInfo*)q;
}

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

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__getConferenceIDs(struct soap *soap, const char *tag, int id, const struct ns__getConferenceIDs *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_ns__getConferenceIDs), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__getConferenceIDs * SOAP_FMAC4 soap_in_ns__getConferenceIDs(struct soap *soap, const char *tag, struct ns__getConferenceIDs *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__getConferenceIDs *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__getConferenceIDs, sizeof(struct ns__getConferenceIDs), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__getConferenceIDs(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 ns__getConferenceIDs *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__getConferenceIDs, 0, sizeof(struct ns__getConferenceIDs), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__getConferenceIDs(struct soap *soap, const struct ns__getConferenceIDs *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__getConferenceIDs);
	if (soap_out_ns__getConferenceIDs(soap, tag?tag:"ns:getConferenceIDs", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__getConferenceIDs(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__getConferenceIDs %p -> %p\n", q, p));
	*(struct ns__getConferenceIDs*)p = *(struct ns__getConferenceIDs*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeChair(struct soap *soap, struct ns__removeChair *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->floorID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeChair(struct soap *soap, const char *tag, int id, const struct ns__removeChair *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_ns__removeChair), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "floorID", -1, &a->floorID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeChair * SOAP_FMAC4 soap_in_ns__removeChair(struct soap *soap, const char *tag, struct ns__removeChair *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_floorID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeChair *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeChair, sizeof(struct ns__removeChair), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeChair(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_floorID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "floorID", &a->floorID, "xsd:unsignedShort"))
				{	soap_flag_floorID--;
					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 ns__removeChair *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeChair, 0, sizeof(struct ns__removeChair), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_floorID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeChair(struct soap *soap, const struct ns__removeChair *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeChair);
	if (soap_out_ns__removeChair(soap, tag?tag:"ns:removeChair", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeChair(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeChair %p -> %p\n", q, p));
	*(struct ns__removeChair*)p = *(struct ns__removeChair*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeChairResponse(struct soap *soap, struct ns__removeChairResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__removeChairResponse(struct soap *soap, const struct ns__removeChairResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeChairResponse(struct soap *soap, const char *tag, int id, const struct ns__removeChairResponse *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_ns__removeChairResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeChairResponse * SOAP_FMAC4 soap_in_ns__removeChairResponse(struct soap *soap, const char *tag, struct ns__removeChairResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeChairResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeChairResponse, sizeof(struct ns__removeChairResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeChairResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__removeChairResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeChairResponse, 0, sizeof(struct ns__removeChairResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeChairResponse(struct soap *soap, const struct ns__removeChairResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeChairResponse);
	if (soap_out_ns__removeChairResponse(soap, tag?tag:"ns:removeChairResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeChairResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeChairResponse %p -> %p\n", q, p));
	*(struct ns__removeChairResponse*)p = *(struct ns__removeChairResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__setChair(struct soap *soap, struct ns__setChair *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->floorID);
	soap_default_unsignedShort(soap, &a->userID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__setChair(struct soap *soap, const char *tag, int id, const struct ns__setChair *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_ns__setChair), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "floorID", -1, &a->floorID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "userID", -1, &a->userID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__setChair * SOAP_FMAC4 soap_in_ns__setChair(struct soap *soap, const char *tag, struct ns__setChair *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_floorID = 1;
	size_t soap_flag_userID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__setChair *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__setChair, sizeof(struct ns__setChair), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__setChair(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_floorID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "floorID", &a->floorID, "xsd:unsignedShort"))
				{	soap_flag_floorID--;
					continue;
				}
			if (soap_flag_userID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "userID", &a->userID, "xsd:unsignedShort"))
				{	soap_flag_userID--;
					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 ns__setChair *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__setChair, 0, sizeof(struct ns__setChair), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_floorID > 0 || soap_flag_userID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__setChair(struct soap *soap, const struct ns__setChair *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__setChair);
	if (soap_out_ns__setChair(soap, tag?tag:"ns:setChair", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__setChair(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__setChair %p -> %p\n", q, p));
	*(struct ns__setChair*)p = *(struct ns__setChair*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__setChairResponse(struct soap *soap, struct ns__setChairResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__setChairResponse(struct soap *soap, const struct ns__setChairResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__setChairResponse(struct soap *soap, const char *tag, int id, const struct ns__setChairResponse *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_ns__setChairResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__setChairResponse * SOAP_FMAC4 soap_in_ns__setChairResponse(struct soap *soap, const char *tag, struct ns__setChairResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__setChairResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__setChairResponse, sizeof(struct ns__setChairResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__setChairResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__setChairResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__setChairResponse, 0, sizeof(struct ns__setChairResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__setChairResponse(struct soap *soap, const struct ns__setChairResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__setChairResponse);
	if (soap_out_ns__setChairResponse(soap, tag?tag:"ns:setChairResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__setChairResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__setChairResponse %p -> %p\n", q, p));
	*(struct ns__setChairResponse*)p = *(struct ns__setChairResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeUser(struct soap *soap, struct ns__removeUser *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->userID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeUser(struct soap *soap, const char *tag, int id, const struct ns__removeUser *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_ns__removeUser), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "userID", -1, &a->userID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeUser * SOAP_FMAC4 soap_in_ns__removeUser(struct soap *soap, const char *tag, struct ns__removeUser *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_userID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeUser *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeUser, sizeof(struct ns__removeUser), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeUser(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_userID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "userID", &a->userID, "xsd:unsignedShort"))
				{	soap_flag_userID--;
					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 ns__removeUser *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeUser, 0, sizeof(struct ns__removeUser), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_userID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeUser(struct soap *soap, const struct ns__removeUser *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeUser);
	if (soap_out_ns__removeUser(soap, tag?tag:"ns:removeUser", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeUser(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeUser %p -> %p\n", q, p));
	*(struct ns__removeUser*)p = *(struct ns__removeUser*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeUserResponse(struct soap *soap, struct ns__removeUserResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__removeUserResponse(struct soap *soap, const struct ns__removeUserResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeUserResponse(struct soap *soap, const char *tag, int id, const struct ns__removeUserResponse *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_ns__removeUserResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeUserResponse * SOAP_FMAC4 soap_in_ns__removeUserResponse(struct soap *soap, const char *tag, struct ns__removeUserResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeUserResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeUserResponse, sizeof(struct ns__removeUserResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeUserResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__removeUserResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeUserResponse, 0, sizeof(struct ns__removeUserResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeUserResponse(struct soap *soap, const struct ns__removeUserResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeUserResponse);
	if (soap_out_ns__removeUserResponse(soap, tag?tag:"ns:removeUserResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeUserResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeUserResponse %p -> %p\n", q, p));
	*(struct ns__removeUserResponse*)p = *(struct ns__removeUserResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addUser(struct soap *soap, struct ns__addUser *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->userID);
	soap_default_xsd__string(soap, &a->userName);
	soap_default_xsd__string(soap, &a->userURI);
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__addUser(struct soap *soap, const struct ns__addUser *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_xsd__string(soap, &a->userName);
	soap_serialize_xsd__string(soap, &a->userURI);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addUser(struct soap *soap, const char *tag, int id, const struct ns__addUser *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_ns__addUser), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "userID", -1, &a->userID, ""))
		return soap->error;
	if (soap_out_xsd__string(soap, "userName", -1, &a->userName, ""))
		return soap->error;
	if (soap_out_xsd__string(soap, "userURI", -1, &a->userURI, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addUser * SOAP_FMAC4 soap_in_ns__addUser(struct soap *soap, const char *tag, struct ns__addUser *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_userID = 1;
	size_t soap_flag_userName = 1;
	size_t soap_flag_userURI = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addUser *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addUser, sizeof(struct ns__addUser), soap->type, soap->arrayType);
	if (!a)
		return NULL;
	soap_default_ns__addUser(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_userID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "userID", &a->userID, "xsd:unsignedShort"))
				{	soap_flag_userID--;
					continue;
				}
			if (soap_flag_userName && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
				if (soap_in_xsd__string(soap, "userName", &a->userName, "xsd:string"))
				{	soap_flag_userName--;
					continue;
				}
			if (soap_flag_userURI && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
				if (soap_in_xsd__string(soap, "userURI", &a->userURI, "xsd:string"))
				{	soap_flag_userURI--;
					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 ns__addUser *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addUser, 0, sizeof(struct ns__addUser), 0, soap_copy_ns__addUser);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_userID > 0 || soap_flag_userName > 0 || soap_flag_userURI > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addUser(struct soap *soap, const struct ns__addUser *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addUser);
	if (soap_out_ns__addUser(soap, tag?tag:"ns:addUser", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addUser(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addUser %p -> %p\n", q, p));
	*(struct ns__addUser*)p = *(struct ns__addUser*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addUserResponse(struct soap *soap, struct ns__addUserResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__addUserResponse(struct soap *soap, const struct ns__addUserResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addUserResponse(struct soap *soap, const char *tag, int id, const struct ns__addUserResponse *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_ns__addUserResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addUserResponse * SOAP_FMAC4 soap_in_ns__addUserResponse(struct soap *soap, const char *tag, struct ns__addUserResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addUserResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addUserResponse, sizeof(struct ns__addUserResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__addUserResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__addUserResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addUserResponse, 0, sizeof(struct ns__addUserResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addUserResponse(struct soap *soap, const struct ns__addUserResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addUserResponse);
	if (soap_out_ns__addUserResponse(soap, tag?tag:"ns:addUserResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addUserResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addUserResponse %p -> %p\n", q, p));
	*(struct ns__addUserResponse*)p = *(struct ns__addUserResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__modifyFloor(struct soap *soap, struct ns__modifyFloor *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->floorID);
	soap_default_unsignedShort(soap, &a->maxGrantedNum);
	soap_default_double(soap, &a->maxHoldingTime);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__modifyFloor(struct soap *soap, const char *tag, int id, const struct ns__modifyFloor *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_ns__modifyFloor), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "floorID", -1, &a->floorID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "maxGrantedNum", -1, &a->maxGrantedNum, ""))
		return soap->error;
	if (soap_out_double(soap, "maxHoldingTime", -1, &a->maxHoldingTime, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__modifyFloor * SOAP_FMAC4 soap_in_ns__modifyFloor(struct soap *soap, const char *tag, struct ns__modifyFloor *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_floorID = 1;
	size_t soap_flag_maxGrantedNum = 1;
	size_t soap_flag_maxHoldingTime = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__modifyFloor *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__modifyFloor, sizeof(struct ns__modifyFloor), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__modifyFloor(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_floorID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "floorID", &a->floorID, "xsd:unsignedShort"))
				{	soap_flag_floorID--;
					continue;
				}
			if (soap_flag_maxGrantedNum && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "maxGrantedNum", &a->maxGrantedNum, "xsd:unsignedShort"))
				{	soap_flag_maxGrantedNum--;
					continue;
				}
			if (soap_flag_maxHoldingTime && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_double(soap, "maxHoldingTime", &a->maxHoldingTime, "xsd:double"))
				{	soap_flag_maxHoldingTime--;
					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 ns__modifyFloor *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__modifyFloor, 0, sizeof(struct ns__modifyFloor), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_floorID > 0 || soap_flag_maxGrantedNum > 0 || soap_flag_maxHoldingTime > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__modifyFloor(struct soap *soap, const struct ns__modifyFloor *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__modifyFloor);
	if (soap_out_ns__modifyFloor(soap, tag?tag:"ns:modifyFloor", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__modifyFloor(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__modifyFloor %p -> %p\n", q, p));
	*(struct ns__modifyFloor*)p = *(struct ns__modifyFloor*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__modifyFloorResponse(struct soap *soap, struct ns__modifyFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__modifyFloorResponse(struct soap *soap, const struct ns__modifyFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__modifyFloorResponse(struct soap *soap, const char *tag, int id, const struct ns__modifyFloorResponse *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_ns__modifyFloorResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__modifyFloorResponse * SOAP_FMAC4 soap_in_ns__modifyFloorResponse(struct soap *soap, const char *tag, struct ns__modifyFloorResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__modifyFloorResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__modifyFloorResponse, sizeof(struct ns__modifyFloorResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__modifyFloorResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__modifyFloorResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__modifyFloorResponse, 0, sizeof(struct ns__modifyFloorResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__modifyFloorResponse(struct soap *soap, const struct ns__modifyFloorResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__modifyFloorResponse);
	if (soap_out_ns__modifyFloorResponse(soap, tag?tag:"ns:modifyFloorResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__modifyFloorResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__modifyFloorResponse %p -> %p\n", q, p));
	*(struct ns__modifyFloorResponse*)p = *(struct ns__modifyFloorResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeFloor(struct soap *soap, struct ns__removeFloor *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->floorID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeFloor(struct soap *soap, const char *tag, int id, const struct ns__removeFloor *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_ns__removeFloor), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "floorID", -1, &a->floorID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeFloor * SOAP_FMAC4 soap_in_ns__removeFloor(struct soap *soap, const char *tag, struct ns__removeFloor *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_floorID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeFloor *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeFloor, sizeof(struct ns__removeFloor), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeFloor(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_floorID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "floorID", &a->floorID, "xsd:unsignedShort"))
				{	soap_flag_floorID--;
					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 ns__removeFloor *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeFloor, 0, sizeof(struct ns__removeFloor), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_floorID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeFloor(struct soap *soap, const struct ns__removeFloor *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeFloor);
	if (soap_out_ns__removeFloor(soap, tag?tag:"ns:removeFloor", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeFloor(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeFloor %p -> %p\n", q, p));
	*(struct ns__removeFloor*)p = *(struct ns__removeFloor*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeFloorResponse(struct soap *soap, struct ns__removeFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__removeFloorResponse(struct soap *soap, const struct ns__removeFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeFloorResponse(struct soap *soap, const char *tag, int id, const struct ns__removeFloorResponse *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_ns__removeFloorResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeFloorResponse * SOAP_FMAC4 soap_in_ns__removeFloorResponse(struct soap *soap, const char *tag, struct ns__removeFloorResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeFloorResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeFloorResponse, sizeof(struct ns__removeFloorResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeFloorResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__removeFloorResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeFloorResponse, 0, sizeof(struct ns__removeFloorResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeFloorResponse(struct soap *soap, const struct ns__removeFloorResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeFloorResponse);
	if (soap_out_ns__removeFloorResponse(soap, tag?tag:"ns:removeFloorResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeFloorResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeFloorResponse %p -> %p\n", q, p));
	*(struct ns__removeFloorResponse*)p = *(struct ns__removeFloorResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addFloor(struct soap *soap, struct ns__addFloor *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->floorID);
	soap_default_unsignedShort(soap, &a->maxGrantedNum);
	soap_default_double(soap, &a->maxHoldingTime);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addFloor(struct soap *soap, const char *tag, int id, const struct ns__addFloor *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_ns__addFloor), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "floorID", -1, &a->floorID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "maxGrantedNum", -1, &a->maxGrantedNum, ""))
		return soap->error;
	if (soap_out_double(soap, "maxHoldingTime", -1, &a->maxHoldingTime, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addFloor * SOAP_FMAC4 soap_in_ns__addFloor(struct soap *soap, const char *tag, struct ns__addFloor *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_floorID = 1;
	size_t soap_flag_maxGrantedNum = 1;
	size_t soap_flag_maxHoldingTime = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addFloor *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addFloor, sizeof(struct ns__addFloor), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__addFloor(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_floorID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "floorID", &a->floorID, "xsd:unsignedShort"))
				{	soap_flag_floorID--;
					continue;
				}
			if (soap_flag_maxGrantedNum && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "maxGrantedNum", &a->maxGrantedNum, "xsd:unsignedShort"))
				{	soap_flag_maxGrantedNum--;
					continue;
				}
			if (soap_flag_maxHoldingTime && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_double(soap, "maxHoldingTime", &a->maxHoldingTime, "xsd:double"))
				{	soap_flag_maxHoldingTime--;
					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 ns__addFloor *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addFloor, 0, sizeof(struct ns__addFloor), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_floorID > 0 || soap_flag_maxGrantedNum > 0 || soap_flag_maxHoldingTime > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addFloor(struct soap *soap, const struct ns__addFloor *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addFloor);
	if (soap_out_ns__addFloor(soap, tag?tag:"ns:addFloor", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addFloor(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addFloor %p -> %p\n", q, p));
	*(struct ns__addFloor*)p = *(struct ns__addFloor*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addFloorResponse(struct soap *soap, struct ns__addFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__addFloorResponse(struct soap *soap, const struct ns__addFloorResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addFloorResponse(struct soap *soap, const char *tag, int id, const struct ns__addFloorResponse *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_ns__addFloorResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addFloorResponse * SOAP_FMAC4 soap_in_ns__addFloorResponse(struct soap *soap, const char *tag, struct ns__addFloorResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addFloorResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addFloorResponse, sizeof(struct ns__addFloorResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__addFloorResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__addFloorResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addFloorResponse, 0, sizeof(struct ns__addFloorResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addFloorResponse(struct soap *soap, const struct ns__addFloorResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addFloorResponse);
	if (soap_out_ns__addFloorResponse(soap, tag?tag:"ns:addFloorResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addFloorResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addFloorResponse %p -> %p\n", q, p));
	*(struct ns__addFloorResponse*)p = *(struct ns__addFloorResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__modifyConference(struct soap *soap, struct ns__modifyConference *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->maxFloorRequest);
	soap_default_ns__Policy(soap, &a->policy);
	soap_default_double(soap, &a->timeForChairAction);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__modifyConference(struct soap *soap, const char *tag, int id, const struct ns__modifyConference *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_ns__modifyConference), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "maxFloorRequest", -1, &a->maxFloorRequest, ""))
		return soap->error;
	if (soap_out_ns__Policy(soap, "policy", -1, &a->policy, ""))
		return soap->error;
	if (soap_out_double(soap, "timeForChairAction", -1, &a->timeForChairAction, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__modifyConference * SOAP_FMAC4 soap_in_ns__modifyConference(struct soap *soap, const char *tag, struct ns__modifyConference *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_maxFloorRequest = 1;
	size_t soap_flag_policy = 1;
	size_t soap_flag_timeForChairAction = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__modifyConference *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__modifyConference, sizeof(struct ns__modifyConference), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__modifyConference(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_maxFloorRequest && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "maxFloorRequest", &a->maxFloorRequest, "xsd:unsignedShort"))
				{	soap_flag_maxFloorRequest--;
					continue;
				}
			if (soap_flag_policy && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_ns__Policy(soap, "policy", &a->policy, "ns:Policy"))
				{	soap_flag_policy--;
					continue;
				}
			if (soap_flag_timeForChairAction && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_double(soap, "timeForChairAction", &a->timeForChairAction, "xsd:double"))
				{	soap_flag_timeForChairAction--;
					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 ns__modifyConference *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__modifyConference, 0, sizeof(struct ns__modifyConference), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_maxFloorRequest > 0 || soap_flag_policy > 0 || soap_flag_timeForChairAction > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__modifyConference(struct soap *soap, const struct ns__modifyConference *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__modifyConference);
	if (soap_out_ns__modifyConference(soap, tag?tag:"ns:modifyConference", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__modifyConference(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__modifyConference %p -> %p\n", q, p));
	*(struct ns__modifyConference*)p = *(struct ns__modifyConference*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__modifyConferenceResponse(struct soap *soap, struct ns__modifyConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__modifyConferenceResponse(struct soap *soap, const struct ns__modifyConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__modifyConferenceResponse(struct soap *soap, const char *tag, int id, const struct ns__modifyConferenceResponse *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_ns__modifyConferenceResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__modifyConferenceResponse * SOAP_FMAC4 soap_in_ns__modifyConferenceResponse(struct soap *soap, const char *tag, struct ns__modifyConferenceResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__modifyConferenceResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__modifyConferenceResponse, sizeof(struct ns__modifyConferenceResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__modifyConferenceResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__modifyConferenceResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__modifyConferenceResponse, 0, sizeof(struct ns__modifyConferenceResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__modifyConferenceResponse(struct soap *soap, const struct ns__modifyConferenceResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__modifyConferenceResponse);
	if (soap_out_ns__modifyConferenceResponse(soap, tag?tag:"ns:modifyConferenceResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__modifyConferenceResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__modifyConferenceResponse %p -> %p\n", q, p));
	*(struct ns__modifyConferenceResponse*)p = *(struct ns__modifyConferenceResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeConference(struct soap *soap, struct ns__removeConference *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeConference(struct soap *soap, const char *tag, int id, const struct ns__removeConference *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_ns__removeConference), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeConference * SOAP_FMAC4 soap_in_ns__removeConference(struct soap *soap, const char *tag, struct ns__removeConference *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeConference *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeConference, sizeof(struct ns__removeConference), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeConference(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					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 ns__removeConference *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeConference, 0, sizeof(struct ns__removeConference), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeConference(struct soap *soap, const struct ns__removeConference *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeConference);
	if (soap_out_ns__removeConference(soap, tag?tag:"ns:removeConference", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeConference(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeConference %p -> %p\n", q, p));
	*(struct ns__removeConference*)p = *(struct ns__removeConference*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__removeConferenceResponse(struct soap *soap, struct ns__removeConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__removeConferenceResponse(struct soap *soap, const struct ns__removeConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__removeConferenceResponse(struct soap *soap, const char *tag, int id, const struct ns__removeConferenceResponse *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_ns__removeConferenceResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__removeConferenceResponse * SOAP_FMAC4 soap_in_ns__removeConferenceResponse(struct soap *soap, const char *tag, struct ns__removeConferenceResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__removeConferenceResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__removeConferenceResponse, sizeof(struct ns__removeConferenceResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__removeConferenceResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__removeConferenceResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__removeConferenceResponse, 0, sizeof(struct ns__removeConferenceResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__removeConferenceResponse(struct soap *soap, const struct ns__removeConferenceResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__removeConferenceResponse);
	if (soap_out_ns__removeConferenceResponse(soap, tag?tag:"ns:removeConferenceResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__removeConferenceResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__removeConferenceResponse %p -> %p\n", q, p));
	*(struct ns__removeConferenceResponse*)p = *(struct ns__removeConferenceResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addConference(struct soap *soap, struct ns__addConference *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_unsignedInt(soap, &a->conferenceID);
	soap_default_unsignedShort(soap, &a->maxFloorRequest);
	soap_default_ns__Policy(soap, &a->policy);
	soap_default_double(soap, &a->timeForChairAction);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addConference(struct soap *soap, const char *tag, int id, const struct ns__addConference *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_ns__addConference), type))
		return soap->error;
	if (soap_out_unsignedInt(soap, "conferenceID", -1, &a->conferenceID, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "maxFloorRequest", -1, &a->maxFloorRequest, ""))
		return soap->error;
	if (soap_out_ns__Policy(soap, "policy", -1, &a->policy, ""))
		return soap->error;
	if (soap_out_double(soap, "timeForChairAction", -1, &a->timeForChairAction, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addConference * SOAP_FMAC4 soap_in_ns__addConference(struct soap *soap, const char *tag, struct ns__addConference *a, const char *type)
{
	size_t soap_flag_conferenceID = 1;
	size_t soap_flag_maxFloorRequest = 1;
	size_t soap_flag_policy = 1;
	size_t soap_flag_timeForChairAction = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addConference *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addConference, sizeof(struct ns__addConference), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__addConference(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_conferenceID && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedInt(soap, "conferenceID", &a->conferenceID, "xsd:unsignedInt"))
				{	soap_flag_conferenceID--;
					continue;
				}
			if (soap_flag_maxFloorRequest && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "maxFloorRequest", &a->maxFloorRequest, "xsd:unsignedShort"))
				{	soap_flag_maxFloorRequest--;
					continue;
				}
			if (soap_flag_policy && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_ns__Policy(soap, "policy", &a->policy, "ns:Policy"))
				{	soap_flag_policy--;
					continue;
				}
			if (soap_flag_timeForChairAction && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_double(soap, "timeForChairAction", &a->timeForChairAction, "xsd:double"))
				{	soap_flag_timeForChairAction--;
					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 ns__addConference *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addConference, 0, sizeof(struct ns__addConference), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_conferenceID > 0 || soap_flag_maxFloorRequest > 0 || soap_flag_policy > 0 || soap_flag_timeForChairAction > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addConference(struct soap *soap, const struct ns__addConference *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addConference);
	if (soap_out_ns__addConference(soap, tag?tag:"ns:addConference", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addConference(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addConference %p -> %p\n", q, p));
	*(struct ns__addConference*)p = *(struct ns__addConference*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__addConferenceResponse(struct soap *soap, struct ns__addConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__addConferenceResponse(struct soap *soap, const struct ns__addConferenceResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__addConferenceResponse(struct soap *soap, const char *tag, int id, const struct ns__addConferenceResponse *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_ns__addConferenceResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__addConferenceResponse * SOAP_FMAC4 soap_in_ns__addConferenceResponse(struct soap *soap, const char *tag, struct ns__addConferenceResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__addConferenceResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__addConferenceResponse, sizeof(struct ns__addConferenceResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__addConferenceResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__addConferenceResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__addConferenceResponse, 0, sizeof(struct ns__addConferenceResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__addConferenceResponse(struct soap *soap, const struct ns__addConferenceResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__addConferenceResponse);
	if (soap_out_ns__addConferenceResponse(soap, tag?tag:"ns:addConferenceResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__addConferenceResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__addConferenceResponse %p -> %p\n", q, p));
	*(struct ns__addConferenceResponse*)p = *(struct ns__addConferenceResponse*)q;
}

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

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__quit(struct soap *soap, const char *tag, int id, const struct ns__quit *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_ns__quit), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__quit * SOAP_FMAC4 soap_in_ns__quit(struct soap *soap, const char *tag, struct ns__quit *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__quit *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__quit, sizeof(struct ns__quit), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__quit(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 ns__quit *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__quit, 0, sizeof(struct ns__quit), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__quit(struct soap *soap, const struct ns__quit *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__quit);
	if (soap_out_ns__quit(soap, tag?tag:"ns:quit", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__quit(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__quit %p -> %p\n", q, p));
	*(struct ns__quit*)p = *(struct ns__quit*)q;
}

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

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__stop(struct soap *soap, const char *tag, int id, const struct ns__stop *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_ns__stop), type))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__stop * SOAP_FMAC4 soap_in_ns__stop(struct soap *soap, const char *tag, struct ns__stop *a, const char *type)
{
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__stop *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__stop, sizeof(struct ns__stop), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__stop(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 ns__stop *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__stop, 0, sizeof(struct ns__stop), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__stop(struct soap *soap, const struct ns__stop *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__stop);
	if (soap_out_ns__stop(soap, tag?tag:"ns:stop", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__stop(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__stop %p -> %p\n", q, p));
	*(struct ns__stop*)p = *(struct ns__stop*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__stopResponse(struct soap *soap, struct ns__stopResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__stopResponse(struct soap *soap, const struct ns__stopResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__stopResponse(struct soap *soap, const char *tag, int id, const struct ns__stopResponse *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_ns__stopResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__stopResponse * SOAP_FMAC4 soap_in_ns__stopResponse(struct soap *soap, const char *tag, struct ns__stopResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__stopResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__stopResponse, sizeof(struct ns__stopResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__stopResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__stopResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__stopResponse, 0, sizeof(struct ns__stopResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__stopResponse(struct soap *soap, const struct ns__stopResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__stopResponse);
	if (soap_out_ns__stopResponse(soap, tag?tag:"ns:stopResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__stopResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__stopResponse %p -> %p\n", q, p));
	*(struct ns__stopResponse*)p = *(struct ns__stopResponse*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__start(struct soap *soap, struct ns__start *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	soap_default_ns__AddrFamily(soap, &a->af);
	soap_default_unsignedShort(soap, &a->port);
	soap_default_bool(soap, &a->enbaleConnectionThread);
	soap_default_int(soap, &a->workThreadNum);
	soap_default_double(soap, &a->userObsoletedTime);
}

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

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__start(struct soap *soap, const char *tag, int id, const struct ns__start *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_ns__start), type))
		return soap->error;
	if (soap_out_ns__AddrFamily(soap, "af", -1, &a->af, ""))
		return soap->error;
	if (soap_out_unsignedShort(soap, "port", -1, &a->port, ""))
		return soap->error;
	if (soap_out_bool(soap, "enbaleConnectionThread", -1, &a->enbaleConnectionThread, ""))
		return soap->error;
	if (soap_out_int(soap, "workThreadNum", -1, &a->workThreadNum, ""))
		return soap->error;
	if (soap_out_double(soap, "userObsoletedTime", -1, &a->userObsoletedTime, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__start * SOAP_FMAC4 soap_in_ns__start(struct soap *soap, const char *tag, struct ns__start *a, const char *type)
{
	size_t soap_flag_af = 1;
	size_t soap_flag_port = 1;
	size_t soap_flag_enbaleConnectionThread = 1;
	size_t soap_flag_workThreadNum = 1;
	size_t soap_flag_userObsoletedTime = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__start *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__start, sizeof(struct ns__start), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__start(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_af && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_ns__AddrFamily(soap, "af", &a->af, "ns:AddrFamily"))
				{	soap_flag_af--;
					continue;
				}
			if (soap_flag_port && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_unsignedShort(soap, "port", &a->port, "xsd:unsignedShort"))
				{	soap_flag_port--;
					continue;
				}
			if (soap_flag_enbaleConnectionThread && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_bool(soap, "enbaleConnectionThread", &a->enbaleConnectionThread, "xsd:boolean"))
				{	soap_flag_enbaleConnectionThread--;
					continue;
				}
			if (soap_flag_workThreadNum && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_int(soap, "workThreadNum", &a->workThreadNum, "xsd:int"))
				{	soap_flag_workThreadNum--;
					continue;
				}
			if (soap_flag_userObsoletedTime && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_double(soap, "userObsoletedTime", &a->userObsoletedTime, "xsd:double"))
				{	soap_flag_userObsoletedTime--;
					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 ns__start *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__start, 0, sizeof(struct ns__start), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_af > 0 || soap_flag_port > 0 || soap_flag_enbaleConnectionThread > 0 || soap_flag_workThreadNum > 0 || soap_flag_userObsoletedTime > 0))
	{	soap->error = SOAP_OCCURS;
		return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__start(struct soap *soap, const struct ns__start *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__start);
	if (soap_out_ns__start(soap, tag?tag:"ns:start", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__start(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__start %p -> %p\n", q, p));
	*(struct ns__start*)p = *(struct ns__start*)q;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_ns__startResponse(struct soap *soap, struct ns__startResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
	a->errorCode = NULL;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_ns__startResponse(struct soap *soap, const struct ns__startResponse *a)
{
	(void)soap; (void)a; /* appease -Wall -Werror */
#ifndef WITH_NOIDREF
	soap_serialize_PointerTons__ErrorCode(soap, &a->errorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_ns__startResponse(struct soap *soap, const char *tag, int id, const struct ns__startResponse *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_ns__startResponse), type))
		return soap->error;
	if (soap_out_PointerTons__ErrorCode(soap, "errorCode", -1, &a->errorCode, ""))
		return soap->error;
	return soap_element_end_out(soap, tag);
}

SOAP_FMAC3 struct ns__startResponse * SOAP_FMAC4 soap_in_ns__startResponse(struct soap *soap, const char *tag, struct ns__startResponse *a, const char *type)
{
	size_t soap_flag_errorCode = 1;
	if (soap_element_begin_in(soap, tag, 0, type))
		return NULL;
	a = (struct ns__startResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_ns__startResponse, sizeof(struct ns__startResponse), 0, NULL, NULL, NULL);
	if (!a)
		return NULL;
	soap_default_ns__startResponse(soap, a);
	if (soap->body && !*soap->href)
	{
		for (;;)
		{	soap->error = SOAP_TAG_MISMATCH;
			if (soap_flag_errorCode && soap->error == SOAP_TAG_MISMATCH)
				if (soap_in_PointerTons__ErrorCode(soap, "errorCode", &a->errorCode, "ns:ErrorCode"))
				{	soap_flag_errorCode--;
					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 ns__startResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_ns__startResponse, 0, sizeof(struct ns__startResponse), 0, NULL);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_ns__startResponse(struct soap *soap, const struct ns__startResponse *a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_ns__startResponse);
	if (soap_out_ns__startResponse(soap, tag?tag:"ns:startResponse", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_ns__startResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct ns__startResponse %p -> %p\n", q, p));
	*(struct ns__startResponse*)p = *(struct ns__startResponse*)q;
}

#ifndef WITH_NOGLOBAL

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
{
#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);
	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);
		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)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerToSOAP_ENV__Reason);
	if (soap_out_PointerToSOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, 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)
{
#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);
	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);
		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)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerToSOAP_ENV__Detail);
	if (soap_out_PointerToSOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, 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)
{
#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)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
	if (id < 0)
		return soap->error;
	return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
}

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);
		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)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerToSOAP_ENV__Code);
	if (soap_out_PointerToSOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, 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_PointerTons__ConferenceInfoResult(struct soap *soap, ns__ConferenceInfoResult *const*a)
{
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE_ns__ConferenceInfoResult))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons__ConferenceInfoResult(struct soap *soap, const char *tag, int id, ns__ConferenceInfoResult *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns__ConferenceInfoResult);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, type);
}

SOAP_FMAC3 ns__ConferenceInfoResult ** SOAP_FMAC4 soap_in_PointerTons__ConferenceInfoResult(struct soap *soap, const char *tag, ns__ConferenceInfoResult **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */

	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (ns__ConferenceInfoResult **)soap_malloc(soap, sizeof(ns__ConferenceInfoResult *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (ns__ConferenceInfoResult *)soap_instantiate_ns__ConferenceInfoResult(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
			return NULL;
	}
	else
	{	ns__ConferenceInfoResult ** p = (ns__ConferenceInfoResult **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns__ConferenceInfoResult, sizeof(ns__ConferenceInfoResult), 0);
		a = p;
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons__ConferenceInfoResult(struct soap *soap, ns__ConferenceInfoResult *const*a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerTons__ConferenceInfoResult);
	if (soap_out_PointerTons__ConferenceInfoResult(soap, tag?tag:"ns:ConferenceInfoResult", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons__ConferenceListResult(struct soap *soap, ns__ConferenceListResult *const*a)
{
#ifndef WITH_NOIDREF
	if (!soap_reference(soap, *a, SOAP_TYPE_ns__ConferenceListResult))
		(*a)->soap_serialize(soap);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons__ConferenceListResult(struct soap *soap, const char *tag, int id, ns__ConferenceListResult *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns__ConferenceListResult);
	if (id < 0)
		return soap->error;
	return (*a)->soap_out(soap, tag, id, type);
}

SOAP_FMAC3 ns__ConferenceListResult ** SOAP_FMAC4 soap_in_PointerTons__ConferenceListResult(struct soap *soap, const char *tag, ns__ConferenceListResult **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */

	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (ns__ConferenceListResult **)soap_malloc(soap, sizeof(ns__ConferenceListResult *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = (ns__ConferenceListResult *)soap_instantiate_ns__ConferenceListResult(soap, -1, soap->type, soap->arrayType, NULL)))
			return NULL;
		(*a)->soap_default(soap);
		if (!(*a)->soap_in(soap, tag, NULL))
			return NULL;
	}
	else
	{	ns__ConferenceListResult ** p = (ns__ConferenceListResult **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns__ConferenceListResult, sizeof(ns__ConferenceListResult), 0);
		a = p;
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons__ConferenceListResult(struct soap *soap, ns__ConferenceListResult *const*a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerTons__ConferenceListResult);
	if (soap_out_PointerTons__ConferenceListResult(soap, tag?tag:"ns:ConferenceListResult", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTons__ErrorCode(struct soap *soap, enum ns__ErrorCode *const*a)
{
#ifndef WITH_NOIDREF
	soap_reference(soap, *a, SOAP_TYPE_ns__ErrorCode);
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTons__ErrorCode(struct soap *soap, const char *tag, int id, enum ns__ErrorCode *const*a, const char *type)
{
	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_ns__ErrorCode);
	if (id < 0)
		return soap->error;
	return soap_out_ns__ErrorCode(soap, tag, id, *a, type);
}

SOAP_FMAC3 enum ns__ErrorCode ** SOAP_FMAC4 soap_in_PointerTons__ErrorCode(struct soap *soap, const char *tag, enum ns__ErrorCode **a, const char *type)
{
	(void)type; /* appease -Wall -Werror */

	if (soap_element_begin_in(soap, tag, 1, NULL))
		return NULL;
	if (!a)
		if (!(a = (enum ns__ErrorCode **)soap_malloc(soap, sizeof(enum ns__ErrorCode *))))
			return NULL;
	*a = NULL;
	if (!soap->null && *soap->href != '#')
	{	soap_revert(soap);
		if (!(*a = soap_in_ns__ErrorCode(soap, tag, *a, type)))
			return NULL;
	}
	else
	{	a = (enum ns__ErrorCode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_ns__ErrorCode, sizeof(enum ns__ErrorCode), 0);
		if (soap->body && soap_element_end_in(soap, tag))
			return NULL;
	}
	return a;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTons__ErrorCode(struct soap *soap, enum ns__ErrorCode *const*a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_PointerTons__ErrorCode);
	if (soap_out_PointerTons__ErrorCode(soap, tag?tag:"ns:ErrorCode", id, a, type))
		return soap->error;
	return soap_putindependent(soap);
}

SOAP_FMAC3 enum ns__ErrorCode ** SOAP_FMAC4 soap_get_PointerTons__ErrorCode(struct soap *soap, enum ns__ErrorCode **p, const char *tag, const char *type)
{
	if ((p = soap_in_PointerTons__ErrorCode(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)
{
#ifndef WITH_NOIDREF
	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)
{	char **p;
	p = soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, 0, -1, NULL);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE__QName);
	if (soap_out__QName(soap, tag?tag:"byte", id, 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_default_string(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT_string
	*a = SOAP_DEFAULT_string;
#else
	*a = (char *)0;
#endif
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
{
#ifndef WITH_NOIDREF
	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)
{	char **p;
	p = soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, 0, -1, NULL);
	return p;
}

SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
{
	register int id = soap_embed(soap, (void*)a, NULL, 0, SOAP_TYPE_string);
	if (soap_out_string(soap, tag?tag:"byte", id, 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;
}

SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedInt(struct soap *soap, std::vector<unsigned int >*p)
{
	(void)soap; /* appease -Wall -Werror */
	p->clear();
}

SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedInt(struct soap *soap, const std::vector<unsigned int >*a)
{
	(void)soap; (void)a;/* appease -Wall -Werror */
#ifndef WITH_NOIDREF
#endif
}

SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedInt(struct soap *soap, const char *tag, int id, const std::vector<unsigned int >*a, const char *type)
{
	(void)id; (void)type; /* appease -Wall -Werror */
	for (std::vector<unsigned int >::const_iterator i = a->begin(); i != a->end(); ++i)
	{
		if (soap_out_unsignedInt(soap, tag, id, &(*i), ""))
			return soap->error;
	}
	return SOAP_OK;
}

SOAP_FMAC3 std::vector<unsigned int >* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedInt(struct soap *soap, const char *tag, std::vector<unsigned int >*a, const char *type)
{
	short soap_flag;
	(void)type; /* appease -Wall -Werror */
	for (soap_flag = 0;; soap_flag = 1)
	{	unsigned int n;
		if (tag && *tag != '-')
		{	if (soap_element_begin_in(soap, tag, 1, NULL))
				break;
			soap_revert(soap);
		}
		soap_default_unsignedInt(soap, &n);
		if (tag && *tag != '-' && (*soap->id || *soap->href))
		{	if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_unsignedInt, SOAP_TYPE_std__vectorTemplateOfunsignedInt, sizeof(unsigned int), 0))
				break;
			if (!soap_in_unsignedInt(soap, tag, NULL, "xsd:unsignedInt"))
				break;
		}
		else if (!soap_in_unsignedInt(soap, tag, &n, "xsd:unsignedInt"))
			break;
		if (!a && !(a = soap_new_std__vectorTemplateOfunsignedInt(soap, -1)))
			return NULL;
		a->push_back(n);
		if (!tag || *tag == '-')
			return a;
	}
	if (soap_flag && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
	{	soap->error = SOAP_OK;
		return a;
	}
	return NULL;
}

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

SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedInt(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
{
	(void)soap; (void)tt; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
	DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector<unsigned int > %p -> %p\n", q, p));
	*(std::vector<unsigned int >*)p = *(std::vector<unsigned int >*)q;
}

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

/* End of soapC.cpp */