/* soapH.h
   Generated by gSOAP 2.8.48 for calculator.h

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

#ifndef soapH_H
#define soapH_H
#include "soapStub.h"
#ifndef WITH_NOIDREF

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap*, const void*, int);

#ifdef __cplusplus
}
#endif
SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap*);
SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap*);
#endif

#ifdef __cplusplus
extern "C" {
#endif
SOAP_FMAC3 void *SOAP_FMAC4 soap_getelement(struct soap*, int*);
SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap*, const void*, const char*, int, int);

#ifdef __cplusplus
}
#endif
SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap*);

SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap);
SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap*, int, const char*, const char*, size_t*);
SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap_clist*);
SOAP_FMAC3 int SOAP_FMAC4 soap_fbase(int, int);
SOAP_FMAC3 void SOAP_FMAC4 soap_finsert(struct soap*, int, int, void*, size_t, const void*, void**);

#ifndef SOAP_TYPE_byte_DEFINED
#define SOAP_TYPE_byte_DEFINED

inline void 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*, const char*, int, const char *, const char*);
SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap*, const char*, char *, const char*);

SOAP_FMAC3 char * SOAP_FMAC4 soap_new_byte(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap*, const char *, const char*, const char*);

inline int soap_write_byte(struct soap *soap, char const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || soap_put_byte(soap, p, "byte", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_byte(struct soap *soap, const char *URL, char const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || soap_put_byte(soap, p, "byte", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_byte(struct soap *soap, const char *URL, char const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || soap_put_byte(soap, p, "byte", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap*, char *, const char*, const char*);

inline int soap_read_byte(struct soap *soap, char *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || soap_get_byte(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_byte(struct soap *soap, const char *URL, char *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_byte(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_byte(struct soap *soap, char *p)
{
	if (soap_read_byte(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE_int_DEFINED
#define SOAP_TYPE_int_DEFINED

inline void 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*, const char*, int, const int *, const char*);
SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap*, const char*, int *, const char*);

SOAP_FMAC3 int * SOAP_FMAC4 soap_new_int(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap*, const int *, const char*, const char*);

inline int soap_write_int(struct soap *soap, int const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || soap_put_int(soap, p, "int", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_int(struct soap *soap, const char *URL, int const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || soap_put_int(soap, p, "int", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_int(struct soap *soap, const char *URL, int const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || soap_put_int(soap, p, "int", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap*, int *, const char*, const char*);

inline int soap_read_int(struct soap *soap, int *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || soap_get_int(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_int(struct soap *soap, const char *URL, int *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_int(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_int(struct soap *soap, int *p)
{
	if (soap_read_int(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE_double_DEFINED
#define SOAP_TYPE_double_DEFINED

inline void 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*, const char*, int, const double *, const char*);
SOAP_FMAC3 double * SOAP_FMAC4 soap_in_double(struct soap*, const char*, double *, const char*);

SOAP_FMAC3 double * SOAP_FMAC4 soap_new_double(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_double(struct soap*, const double *, const char*, const char*);

inline int soap_write_double(struct soap *soap, double const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || soap_put_double(soap, p, "double", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_double(struct soap *soap, const char *URL, double const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || soap_put_double(soap, p, "double", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_double(struct soap *soap, const char *URL, double const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || soap_put_double(soap, p, "double", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 double * SOAP_FMAC4 soap_get_double(struct soap*, double *, const char*, const char*);

inline int soap_read_double(struct soap *soap, double *p)
{
	if (p)
	{	if (soap_begin_recv(soap) || soap_get_double(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_double(struct soap *soap, const char *URL, double *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_double(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_double(struct soap *soap, double *p)
{
	if (soap_read_double(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__DivideResponse_DEFINED
#define SOAP_TYPE__mssamt__DivideResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__DivideResponse(struct soap*, const char*, int, const _mssamt__DivideResponse *, const char*);
SOAP_FMAC3 _mssamt__DivideResponse * SOAP_FMAC4 soap_in__mssamt__DivideResponse(struct soap*, const char*, _mssamt__DivideResponse *, const char*);
SOAP_FMAC1 _mssamt__DivideResponse * SOAP_FMAC2 soap_instantiate__mssamt__DivideResponse(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__DivideResponse * soap_new__mssamt__DivideResponse(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__DivideResponse(soap, n, NULL, NULL, NULL);
}

inline _mssamt__DivideResponse * soap_new_req__mssamt__DivideResponse(
	struct soap *soap)
{
	_mssamt__DivideResponse *_p = soap_new__mssamt__DivideResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__DivideResponse * soap_new_set__mssamt__DivideResponse(
	struct soap *soap,
	double *DivideResult)
{
	_mssamt__DivideResponse *_p = soap_new__mssamt__DivideResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__DivideResponse::DivideResult = DivideResult;
	}
	return _p;
}

inline int soap_write__mssamt__DivideResponse(struct soap *soap, _mssamt__DivideResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:DivideResponse", p->soap_type() == SOAP_TYPE__mssamt__DivideResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__DivideResponse(struct soap *soap, const char *URL, _mssamt__DivideResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:DivideResponse", p->soap_type() == SOAP_TYPE__mssamt__DivideResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__DivideResponse(struct soap *soap, const char *URL, _mssamt__DivideResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:DivideResponse", p->soap_type() == SOAP_TYPE__mssamt__DivideResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__DivideResponse * SOAP_FMAC4 soap_get__mssamt__DivideResponse(struct soap*, _mssamt__DivideResponse *, const char*, const char*);

inline int soap_read__mssamt__DivideResponse(struct soap *soap, _mssamt__DivideResponse *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__DivideResponse(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__DivideResponse(struct soap *soap, const char *URL, _mssamt__DivideResponse *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__DivideResponse(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__DivideResponse(struct soap *soap, _mssamt__DivideResponse *p)
{
	if (soap_read__mssamt__DivideResponse(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__Divide_DEFINED
#define SOAP_TYPE__mssamt__Divide_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__Divide(struct soap*, const char*, int, const _mssamt__Divide *, const char*);
SOAP_FMAC3 _mssamt__Divide * SOAP_FMAC4 soap_in__mssamt__Divide(struct soap*, const char*, _mssamt__Divide *, const char*);
SOAP_FMAC1 _mssamt__Divide * SOAP_FMAC2 soap_instantiate__mssamt__Divide(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__Divide * soap_new__mssamt__Divide(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__Divide(soap, n, NULL, NULL, NULL);
}

inline _mssamt__Divide * soap_new_req__mssamt__Divide(
	struct soap *soap)
{
	_mssamt__Divide *_p = soap_new__mssamt__Divide(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__Divide * soap_new_set__mssamt__Divide(
	struct soap *soap,
	double *n1,
	double *n2)
{
	_mssamt__Divide *_p = soap_new__mssamt__Divide(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__Divide::n1 = n1;
		_p->_mssamt__Divide::n2 = n2;
	}
	return _p;
}

inline int soap_write__mssamt__Divide(struct soap *soap, _mssamt__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Divide", p->soap_type() == SOAP_TYPE__mssamt__Divide ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__Divide(struct soap *soap, const char *URL, _mssamt__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Divide", p->soap_type() == SOAP_TYPE__mssamt__Divide ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__Divide(struct soap *soap, const char *URL, _mssamt__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Divide", p->soap_type() == SOAP_TYPE__mssamt__Divide ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__Divide * SOAP_FMAC4 soap_get__mssamt__Divide(struct soap*, _mssamt__Divide *, const char*, const char*);

inline int soap_read__mssamt__Divide(struct soap *soap, _mssamt__Divide *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__Divide(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__Divide(struct soap *soap, const char *URL, _mssamt__Divide *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__Divide(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__Divide(struct soap *soap, _mssamt__Divide *p)
{
	if (soap_read__mssamt__Divide(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__MultiplyResponse_DEFINED
#define SOAP_TYPE__mssamt__MultiplyResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__MultiplyResponse(struct soap*, const char*, int, const _mssamt__MultiplyResponse *, const char*);
SOAP_FMAC3 _mssamt__MultiplyResponse * SOAP_FMAC4 soap_in__mssamt__MultiplyResponse(struct soap*, const char*, _mssamt__MultiplyResponse *, const char*);
SOAP_FMAC1 _mssamt__MultiplyResponse * SOAP_FMAC2 soap_instantiate__mssamt__MultiplyResponse(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__MultiplyResponse * soap_new__mssamt__MultiplyResponse(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__MultiplyResponse(soap, n, NULL, NULL, NULL);
}

inline _mssamt__MultiplyResponse * soap_new_req__mssamt__MultiplyResponse(
	struct soap *soap)
{
	_mssamt__MultiplyResponse *_p = soap_new__mssamt__MultiplyResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__MultiplyResponse * soap_new_set__mssamt__MultiplyResponse(
	struct soap *soap,
	double *MultiplyResult)
{
	_mssamt__MultiplyResponse *_p = soap_new__mssamt__MultiplyResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__MultiplyResponse::MultiplyResult = MultiplyResult;
	}
	return _p;
}

inline int soap_write__mssamt__MultiplyResponse(struct soap *soap, _mssamt__MultiplyResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:MultiplyResponse", p->soap_type() == SOAP_TYPE__mssamt__MultiplyResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__MultiplyResponse(struct soap *soap, const char *URL, _mssamt__MultiplyResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:MultiplyResponse", p->soap_type() == SOAP_TYPE__mssamt__MultiplyResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__MultiplyResponse(struct soap *soap, const char *URL, _mssamt__MultiplyResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:MultiplyResponse", p->soap_type() == SOAP_TYPE__mssamt__MultiplyResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__MultiplyResponse * SOAP_FMAC4 soap_get__mssamt__MultiplyResponse(struct soap*, _mssamt__MultiplyResponse *, const char*, const char*);

inline int soap_read__mssamt__MultiplyResponse(struct soap *soap, _mssamt__MultiplyResponse *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__MultiplyResponse(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__MultiplyResponse(struct soap *soap, const char *URL, _mssamt__MultiplyResponse *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__MultiplyResponse(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__MultiplyResponse(struct soap *soap, _mssamt__MultiplyResponse *p)
{
	if (soap_read__mssamt__MultiplyResponse(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__Multiply_DEFINED
#define SOAP_TYPE__mssamt__Multiply_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__Multiply(struct soap*, const char*, int, const _mssamt__Multiply *, const char*);
SOAP_FMAC3 _mssamt__Multiply * SOAP_FMAC4 soap_in__mssamt__Multiply(struct soap*, const char*, _mssamt__Multiply *, const char*);
SOAP_FMAC1 _mssamt__Multiply * SOAP_FMAC2 soap_instantiate__mssamt__Multiply(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__Multiply * soap_new__mssamt__Multiply(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__Multiply(soap, n, NULL, NULL, NULL);
}

inline _mssamt__Multiply * soap_new_req__mssamt__Multiply(
	struct soap *soap)
{
	_mssamt__Multiply *_p = soap_new__mssamt__Multiply(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__Multiply * soap_new_set__mssamt__Multiply(
	struct soap *soap,
	double *n1,
	double *n2)
{
	_mssamt__Multiply *_p = soap_new__mssamt__Multiply(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__Multiply::n1 = n1;
		_p->_mssamt__Multiply::n2 = n2;
	}
	return _p;
}

inline int soap_write__mssamt__Multiply(struct soap *soap, _mssamt__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Multiply", p->soap_type() == SOAP_TYPE__mssamt__Multiply ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__Multiply(struct soap *soap, const char *URL, _mssamt__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Multiply", p->soap_type() == SOAP_TYPE__mssamt__Multiply ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__Multiply(struct soap *soap, const char *URL, _mssamt__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Multiply", p->soap_type() == SOAP_TYPE__mssamt__Multiply ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__Multiply * SOAP_FMAC4 soap_get__mssamt__Multiply(struct soap*, _mssamt__Multiply *, const char*, const char*);

inline int soap_read__mssamt__Multiply(struct soap *soap, _mssamt__Multiply *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__Multiply(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__Multiply(struct soap *soap, const char *URL, _mssamt__Multiply *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__Multiply(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__Multiply(struct soap *soap, _mssamt__Multiply *p)
{
	if (soap_read__mssamt__Multiply(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__SubtractResponse_DEFINED
#define SOAP_TYPE__mssamt__SubtractResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__SubtractResponse(struct soap*, const char*, int, const _mssamt__SubtractResponse *, const char*);
SOAP_FMAC3 _mssamt__SubtractResponse * SOAP_FMAC4 soap_in__mssamt__SubtractResponse(struct soap*, const char*, _mssamt__SubtractResponse *, const char*);
SOAP_FMAC1 _mssamt__SubtractResponse * SOAP_FMAC2 soap_instantiate__mssamt__SubtractResponse(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__SubtractResponse * soap_new__mssamt__SubtractResponse(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__SubtractResponse(soap, n, NULL, NULL, NULL);
}

inline _mssamt__SubtractResponse * soap_new_req__mssamt__SubtractResponse(
	struct soap *soap)
{
	_mssamt__SubtractResponse *_p = soap_new__mssamt__SubtractResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__SubtractResponse * soap_new_set__mssamt__SubtractResponse(
	struct soap *soap,
	double *SubtractResult)
{
	_mssamt__SubtractResponse *_p = soap_new__mssamt__SubtractResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__SubtractResponse::SubtractResult = SubtractResult;
	}
	return _p;
}

inline int soap_write__mssamt__SubtractResponse(struct soap *soap, _mssamt__SubtractResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:SubtractResponse", p->soap_type() == SOAP_TYPE__mssamt__SubtractResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__SubtractResponse(struct soap *soap, const char *URL, _mssamt__SubtractResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:SubtractResponse", p->soap_type() == SOAP_TYPE__mssamt__SubtractResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__SubtractResponse(struct soap *soap, const char *URL, _mssamt__SubtractResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:SubtractResponse", p->soap_type() == SOAP_TYPE__mssamt__SubtractResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__SubtractResponse * SOAP_FMAC4 soap_get__mssamt__SubtractResponse(struct soap*, _mssamt__SubtractResponse *, const char*, const char*);

inline int soap_read__mssamt__SubtractResponse(struct soap *soap, _mssamt__SubtractResponse *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__SubtractResponse(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__SubtractResponse(struct soap *soap, const char *URL, _mssamt__SubtractResponse *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__SubtractResponse(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__SubtractResponse(struct soap *soap, _mssamt__SubtractResponse *p)
{
	if (soap_read__mssamt__SubtractResponse(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__Subtract_DEFINED
#define SOAP_TYPE__mssamt__Subtract_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__Subtract(struct soap*, const char*, int, const _mssamt__Subtract *, const char*);
SOAP_FMAC3 _mssamt__Subtract * SOAP_FMAC4 soap_in__mssamt__Subtract(struct soap*, const char*, _mssamt__Subtract *, const char*);
SOAP_FMAC1 _mssamt__Subtract * SOAP_FMAC2 soap_instantiate__mssamt__Subtract(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__Subtract * soap_new__mssamt__Subtract(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__Subtract(soap, n, NULL, NULL, NULL);
}

inline _mssamt__Subtract * soap_new_req__mssamt__Subtract(
	struct soap *soap)
{
	_mssamt__Subtract *_p = soap_new__mssamt__Subtract(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__Subtract * soap_new_set__mssamt__Subtract(
	struct soap *soap,
	double *n1,
	double *n2)
{
	_mssamt__Subtract *_p = soap_new__mssamt__Subtract(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__Subtract::n1 = n1;
		_p->_mssamt__Subtract::n2 = n2;
	}
	return _p;
}

inline int soap_write__mssamt__Subtract(struct soap *soap, _mssamt__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Subtract", p->soap_type() == SOAP_TYPE__mssamt__Subtract ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__Subtract(struct soap *soap, const char *URL, _mssamt__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Subtract", p->soap_type() == SOAP_TYPE__mssamt__Subtract ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__Subtract(struct soap *soap, const char *URL, _mssamt__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Subtract", p->soap_type() == SOAP_TYPE__mssamt__Subtract ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__Subtract * SOAP_FMAC4 soap_get__mssamt__Subtract(struct soap*, _mssamt__Subtract *, const char*, const char*);

inline int soap_read__mssamt__Subtract(struct soap *soap, _mssamt__Subtract *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__Subtract(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__Subtract(struct soap *soap, const char *URL, _mssamt__Subtract *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__Subtract(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__Subtract(struct soap *soap, _mssamt__Subtract *p)
{
	if (soap_read__mssamt__Subtract(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__AddResponse_DEFINED
#define SOAP_TYPE__mssamt__AddResponse_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__AddResponse(struct soap*, const char*, int, const _mssamt__AddResponse *, const char*);
SOAP_FMAC3 _mssamt__AddResponse * SOAP_FMAC4 soap_in__mssamt__AddResponse(struct soap*, const char*, _mssamt__AddResponse *, const char*);
SOAP_FMAC1 _mssamt__AddResponse * SOAP_FMAC2 soap_instantiate__mssamt__AddResponse(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__AddResponse * soap_new__mssamt__AddResponse(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__AddResponse(soap, n, NULL, NULL, NULL);
}

inline _mssamt__AddResponse * soap_new_req__mssamt__AddResponse(
	struct soap *soap)
{
	_mssamt__AddResponse *_p = soap_new__mssamt__AddResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__AddResponse * soap_new_set__mssamt__AddResponse(
	struct soap *soap,
	double *AddResult)
{
	_mssamt__AddResponse *_p = soap_new__mssamt__AddResponse(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__AddResponse::AddResult = AddResult;
	}
	return _p;
}

inline int soap_write__mssamt__AddResponse(struct soap *soap, _mssamt__AddResponse const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:AddResponse", p->soap_type() == SOAP_TYPE__mssamt__AddResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__AddResponse(struct soap *soap, const char *URL, _mssamt__AddResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:AddResponse", p->soap_type() == SOAP_TYPE__mssamt__AddResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__AddResponse(struct soap *soap, const char *URL, _mssamt__AddResponse const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:AddResponse", p->soap_type() == SOAP_TYPE__mssamt__AddResponse ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__AddResponse * SOAP_FMAC4 soap_get__mssamt__AddResponse(struct soap*, _mssamt__AddResponse *, const char*, const char*);

inline int soap_read__mssamt__AddResponse(struct soap *soap, _mssamt__AddResponse *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__AddResponse(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__AddResponse(struct soap *soap, const char *URL, _mssamt__AddResponse *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__AddResponse(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__AddResponse(struct soap *soap, _mssamt__AddResponse *p)
{
	if (soap_read__mssamt__AddResponse(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__mssamt__Add_DEFINED
#define SOAP_TYPE__mssamt__Add_DEFINED
SOAP_FMAC3 int SOAP_FMAC4 soap_out__mssamt__Add(struct soap*, const char*, int, const _mssamt__Add *, const char*);
SOAP_FMAC3 _mssamt__Add * SOAP_FMAC4 soap_in__mssamt__Add(struct soap*, const char*, _mssamt__Add *, const char*);
SOAP_FMAC1 _mssamt__Add * SOAP_FMAC2 soap_instantiate__mssamt__Add(struct soap*, int, const char*, const char*, size_t*);

inline _mssamt__Add * soap_new__mssamt__Add(struct soap *soap, int n = -1)
{
	return soap_instantiate__mssamt__Add(soap, n, NULL, NULL, NULL);
}

inline _mssamt__Add * soap_new_req__mssamt__Add(
	struct soap *soap)
{
	_mssamt__Add *_p = soap_new__mssamt__Add(soap);
	if (_p)
	{	_p->soap_default(soap);
	}
	return _p;
}

inline _mssamt__Add * soap_new_set__mssamt__Add(
	struct soap *soap,
	double *n1,
	double *n2)
{
	_mssamt__Add *_p = soap_new__mssamt__Add(soap);
	if (_p)
	{	_p->soap_default(soap);
		_p->_mssamt__Add::n1 = n1;
		_p->_mssamt__Add::n2 = n2;
	}
	return _p;
}

inline int soap_write__mssamt__Add(struct soap *soap, _mssamt__Add const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Add", p->soap_type() == SOAP_TYPE__mssamt__Add ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_PUT__mssamt__Add(struct soap *soap, const char *URL, _mssamt__Add const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Add", p->soap_type() == SOAP_TYPE__mssamt__Add ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__mssamt__Add(struct soap *soap, const char *URL, _mssamt__Add const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (p->soap_serialize(soap), 0) || p->soap_put(soap, "mssamt:Add", p->soap_type() == SOAP_TYPE__mssamt__Add ? "" : NULL) || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 _mssamt__Add * SOAP_FMAC4 soap_get__mssamt__Add(struct soap*, _mssamt__Add *, const char*, const char*);

inline int soap_read__mssamt__Add(struct soap *soap, _mssamt__Add *p)
{
	if (p)
	{	p->soap_default(soap);
		if (soap_begin_recv(soap) || soap_get__mssamt__Add(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__mssamt__Add(struct soap *soap, const char *URL, _mssamt__Add *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__mssamt__Add(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__mssamt__Add(struct soap *soap, _mssamt__Add *p)
{
	if (soap_read__mssamt__Add(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Fault_DEFINED
#define SOAP_TYPE_SOAP_ENV__Fault_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap*, const char*, int, const struct SOAP_ENV__Fault *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap*, const char*, struct SOAP_ENV__Fault *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Fault * soap_new_SOAP_ENV__Fault(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Fault(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Fault * soap_new_req_SOAP_ENV__Fault(
	struct soap *soap)
{
	struct SOAP_ENV__Fault *_p = soap_new_SOAP_ENV__Fault(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Fault(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Fault * soap_new_set_SOAP_ENV__Fault(
	struct soap *soap,
	char *faultcode,
	char *faultstring,
	char *faultactor,
	struct SOAP_ENV__Detail *detail,
	struct SOAP_ENV__Code *SOAP_ENV__Code,
	struct SOAP_ENV__Reason *SOAP_ENV__Reason,
	char *SOAP_ENV__Node,
	char *SOAP_ENV__Role,
	struct SOAP_ENV__Detail *SOAP_ENV__Detail)
{
	struct SOAP_ENV__Fault *_p = soap_new_SOAP_ENV__Fault(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Fault(soap, _p);
		_p->faultcode = faultcode;
		_p->faultstring = faultstring;
		_p->faultactor = faultactor;
		_p->detail = detail;
		_p->SOAP_ENV__Code = SOAP_ENV__Code;
		_p->SOAP_ENV__Reason = SOAP_ENV__Reason;
		_p->SOAP_ENV__Node = SOAP_ENV__Node;
		_p->SOAP_ENV__Role = SOAP_ENV__Role;
		_p->SOAP_ENV__Detail = SOAP_ENV__Detail;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *, const char*, const char*);

inline int soap_write_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize_SOAP_ENV__Fault(soap, p), 0) || soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize_SOAP_ENV__Fault(soap, p), 0) || soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize_SOAP_ENV__Fault(soap, p), 0) || soap_put_SOAP_ENV__Fault(soap, p, "SOAP-ENV:Fault", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *, const char*, const char*);

inline int soap_read_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
{
	if (p)
	{	soap_default_SOAP_ENV__Fault(soap, p);
		if (soap_begin_recv(soap) || soap_get_SOAP_ENV__Fault(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Fault(struct soap *soap, const char *URL, struct SOAP_ENV__Fault *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_SOAP_ENV__Fault(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
{
	if (soap_read_SOAP_ENV__Fault(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Reason_DEFINED
#define SOAP_TYPE_SOAP_ENV__Reason_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap*, const char*, int, const struct SOAP_ENV__Reason *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Reason * soap_new_SOAP_ENV__Reason(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Reason(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Reason * soap_new_req_SOAP_ENV__Reason(
	struct soap *soap)
{
	struct SOAP_ENV__Reason *_p = soap_new_SOAP_ENV__Reason(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Reason(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Reason * soap_new_set_SOAP_ENV__Reason(
	struct soap *soap,
	char *SOAP_ENV__Text)
{
	struct SOAP_ENV__Reason *_p = soap_new_SOAP_ENV__Reason(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Reason(soap, _p);
		_p->SOAP_ENV__Text = SOAP_ENV__Text;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *, const char*, const char*);

inline int soap_write_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize_SOAP_ENV__Reason(soap, p), 0) || soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize_SOAP_ENV__Reason(soap, p), 0) || soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize_SOAP_ENV__Reason(soap, p), 0) || soap_put_SOAP_ENV__Reason(soap, p, "SOAP-ENV:Reason", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *, const char*, const char*);

inline int soap_read_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
{
	if (p)
	{	soap_default_SOAP_ENV__Reason(soap, p);
		if (soap_begin_recv(soap) || soap_get_SOAP_ENV__Reason(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Reason(struct soap *soap, const char *URL, struct SOAP_ENV__Reason *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_SOAP_ENV__Reason(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
{
	if (soap_read_SOAP_ENV__Reason(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Detail_DEFINED
#define SOAP_TYPE_SOAP_ENV__Detail_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap*, const char*, int, const struct SOAP_ENV__Detail *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Detail * soap_new_SOAP_ENV__Detail(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Detail(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Detail * soap_new_req_SOAP_ENV__Detail(
	struct soap *soap,
	int __type,
	void *fault)
{
	struct SOAP_ENV__Detail *_p = soap_new_SOAP_ENV__Detail(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Detail(soap, _p);
		_p->__type = __type;
		_p->fault = fault;
	}
	return _p;
}

inline struct SOAP_ENV__Detail * soap_new_set_SOAP_ENV__Detail(
	struct soap *soap,
	char *__any,
	int __type,
	void *fault)
{
	struct SOAP_ENV__Detail *_p = soap_new_SOAP_ENV__Detail(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Detail(soap, _p);
		_p->__any = __any;
		_p->__type = __type;
		_p->fault = fault;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *, const char*, const char*);

inline int soap_write_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize_SOAP_ENV__Detail(soap, p), 0) || soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize_SOAP_ENV__Detail(soap, p), 0) || soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize_SOAP_ENV__Detail(soap, p), 0) || soap_put_SOAP_ENV__Detail(soap, p, "SOAP-ENV:Detail", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *, const char*, const char*);

inline int soap_read_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
{
	if (p)
	{	soap_default_SOAP_ENV__Detail(soap, p);
		if (soap_begin_recv(soap) || soap_get_SOAP_ENV__Detail(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Detail(struct soap *soap, const char *URL, struct SOAP_ENV__Detail *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_SOAP_ENV__Detail(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
{
	if (soap_read_SOAP_ENV__Detail(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Code_DEFINED
#define SOAP_TYPE_SOAP_ENV__Code_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap*, const char*, int, const struct SOAP_ENV__Code *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Code * soap_new_SOAP_ENV__Code(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Code(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Code * soap_new_req_SOAP_ENV__Code(
	struct soap *soap)
{
	struct SOAP_ENV__Code *_p = soap_new_SOAP_ENV__Code(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Code(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Code * soap_new_set_SOAP_ENV__Code(
	struct soap *soap,
	char *SOAP_ENV__Value,
	struct SOAP_ENV__Code *SOAP_ENV__Subcode)
{
	struct SOAP_ENV__Code *_p = soap_new_SOAP_ENV__Code(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Code(soap, _p);
		_p->SOAP_ENV__Value = SOAP_ENV__Value;
		_p->SOAP_ENV__Subcode = SOAP_ENV__Subcode;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *, const char*, const char*);

inline int soap_write_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize_SOAP_ENV__Code(soap, p), 0) || soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize_SOAP_ENV__Code(soap, p), 0) || soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize_SOAP_ENV__Code(soap, p), 0) || soap_put_SOAP_ENV__Code(soap, p, "SOAP-ENV:Code", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *, const char*, const char*);

inline int soap_read_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
{
	if (p)
	{	soap_default_SOAP_ENV__Code(soap, p);
		if (soap_begin_recv(soap) || soap_get_SOAP_ENV__Code(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Code(struct soap *soap, const char *URL, struct SOAP_ENV__Code *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_SOAP_ENV__Code(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
{
	if (soap_read_SOAP_ENV__Code(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_SOAP_ENV__Header_DEFINED
#define SOAP_TYPE_SOAP_ENV__Header_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap*, const char*, int, const struct SOAP_ENV__Header *, const char*);
SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap*, const char*, struct SOAP_ENV__Header *, const char*);
SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap*, int, const char*, const char*, size_t*);

inline struct SOAP_ENV__Header * soap_new_SOAP_ENV__Header(struct soap *soap, int n = -1)
{
	return soap_instantiate_SOAP_ENV__Header(soap, n, NULL, NULL, NULL);
}

inline struct SOAP_ENV__Header * soap_new_req_SOAP_ENV__Header(
	struct soap *soap)
{
	struct SOAP_ENV__Header *_p = soap_new_SOAP_ENV__Header(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Header(soap, _p);
	}
	return _p;
}

inline struct SOAP_ENV__Header * soap_new_set_SOAP_ENV__Header(
	struct soap *soap)
{
	struct SOAP_ENV__Header *_p = soap_new_SOAP_ENV__Header(soap);
	if (_p)
	{	soap_default_SOAP_ENV__Header(soap, _p);
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *, const char*, const char*);

inline int soap_write_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize_SOAP_ENV__Header(soap, p), 0) || soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize_SOAP_ENV__Header(soap, p), 0) || soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize_SOAP_ENV__Header(soap, p), 0) || soap_put_SOAP_ENV__Header(soap, p, "SOAP-ENV:Header", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *, const char*, const char*);

inline int soap_read_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
{
	if (p)
	{	soap_default_SOAP_ENV__Header(soap, p);
		if (soap_begin_recv(soap) || soap_get_SOAP_ENV__Header(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_SOAP_ENV__Header(struct soap *soap, const char *URL, struct SOAP_ENV__Header *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_SOAP_ENV__Header(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
{
	if (soap_read_SOAP_ENV__Header(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

#ifndef SOAP_TYPE___tempuri__Divide_DEFINED
#define SOAP_TYPE___tempuri__Divide_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tempuri__Divide(struct soap*, struct __tempuri__Divide *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tempuri__Divide(struct soap*, const struct __tempuri__Divide *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tempuri__Divide(struct soap*, const char*, int, const struct __tempuri__Divide *, const char*);
SOAP_FMAC3 struct __tempuri__Divide * SOAP_FMAC4 soap_in___tempuri__Divide(struct soap*, const char*, struct __tempuri__Divide *, const char*);
SOAP_FMAC1 struct __tempuri__Divide * SOAP_FMAC2 soap_instantiate___tempuri__Divide(struct soap*, int, const char*, const char*, size_t*);

inline struct __tempuri__Divide * soap_new___tempuri__Divide(struct soap *soap, int n = -1)
{
	return soap_instantiate___tempuri__Divide(soap, n, NULL, NULL, NULL);
}

inline struct __tempuri__Divide * soap_new_req___tempuri__Divide(
	struct soap *soap)
{
	struct __tempuri__Divide *_p = soap_new___tempuri__Divide(soap);
	if (_p)
	{	soap_default___tempuri__Divide(soap, _p);
	}
	return _p;
}

inline struct __tempuri__Divide * soap_new_set___tempuri__Divide(
	struct soap *soap,
	_mssamt__Divide *mssamt__Divide)
{
	struct __tempuri__Divide *_p = soap_new___tempuri__Divide(soap);
	if (_p)
	{	soap_default___tempuri__Divide(soap, _p);
		_p->mssamt__Divide = mssamt__Divide;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tempuri__Divide(struct soap*, const struct __tempuri__Divide *, const char*, const char*);

inline int soap_write___tempuri__Divide(struct soap *soap, struct __tempuri__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize___tempuri__Divide(soap, p), 0) || soap_put___tempuri__Divide(soap, p, "-tempuri:Divide", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tempuri__Divide(struct soap *soap, const char *URL, struct __tempuri__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize___tempuri__Divide(soap, p), 0) || soap_put___tempuri__Divide(soap, p, "-tempuri:Divide", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send___tempuri__Divide(struct soap *soap, const char *URL, struct __tempuri__Divide const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize___tempuri__Divide(soap, p), 0) || soap_put___tempuri__Divide(soap, p, "-tempuri:Divide", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct __tempuri__Divide * SOAP_FMAC4 soap_get___tempuri__Divide(struct soap*, struct __tempuri__Divide *, const char*, const char*);

inline int soap_read___tempuri__Divide(struct soap *soap, struct __tempuri__Divide *p)
{
	if (p)
	{	soap_default___tempuri__Divide(soap, p);
		if (soap_begin_recv(soap) || soap_get___tempuri__Divide(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tempuri__Divide(struct soap *soap, const char *URL, struct __tempuri__Divide *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read___tempuri__Divide(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv___tempuri__Divide(struct soap *soap, struct __tempuri__Divide *p)
{
	if (soap_read___tempuri__Divide(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE___tempuri__Multiply_DEFINED
#define SOAP_TYPE___tempuri__Multiply_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tempuri__Multiply(struct soap*, struct __tempuri__Multiply *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tempuri__Multiply(struct soap*, const struct __tempuri__Multiply *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tempuri__Multiply(struct soap*, const char*, int, const struct __tempuri__Multiply *, const char*);
SOAP_FMAC3 struct __tempuri__Multiply * SOAP_FMAC4 soap_in___tempuri__Multiply(struct soap*, const char*, struct __tempuri__Multiply *, const char*);
SOAP_FMAC1 struct __tempuri__Multiply * SOAP_FMAC2 soap_instantiate___tempuri__Multiply(struct soap*, int, const char*, const char*, size_t*);

inline struct __tempuri__Multiply * soap_new___tempuri__Multiply(struct soap *soap, int n = -1)
{
	return soap_instantiate___tempuri__Multiply(soap, n, NULL, NULL, NULL);
}

inline struct __tempuri__Multiply * soap_new_req___tempuri__Multiply(
	struct soap *soap)
{
	struct __tempuri__Multiply *_p = soap_new___tempuri__Multiply(soap);
	if (_p)
	{	soap_default___tempuri__Multiply(soap, _p);
	}
	return _p;
}

inline struct __tempuri__Multiply * soap_new_set___tempuri__Multiply(
	struct soap *soap,
	_mssamt__Multiply *mssamt__Multiply)
{
	struct __tempuri__Multiply *_p = soap_new___tempuri__Multiply(soap);
	if (_p)
	{	soap_default___tempuri__Multiply(soap, _p);
		_p->mssamt__Multiply = mssamt__Multiply;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tempuri__Multiply(struct soap*, const struct __tempuri__Multiply *, const char*, const char*);

inline int soap_write___tempuri__Multiply(struct soap *soap, struct __tempuri__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize___tempuri__Multiply(soap, p), 0) || soap_put___tempuri__Multiply(soap, p, "-tempuri:Multiply", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tempuri__Multiply(struct soap *soap, const char *URL, struct __tempuri__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize___tempuri__Multiply(soap, p), 0) || soap_put___tempuri__Multiply(soap, p, "-tempuri:Multiply", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send___tempuri__Multiply(struct soap *soap, const char *URL, struct __tempuri__Multiply const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize___tempuri__Multiply(soap, p), 0) || soap_put___tempuri__Multiply(soap, p, "-tempuri:Multiply", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct __tempuri__Multiply * SOAP_FMAC4 soap_get___tempuri__Multiply(struct soap*, struct __tempuri__Multiply *, const char*, const char*);

inline int soap_read___tempuri__Multiply(struct soap *soap, struct __tempuri__Multiply *p)
{
	if (p)
	{	soap_default___tempuri__Multiply(soap, p);
		if (soap_begin_recv(soap) || soap_get___tempuri__Multiply(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tempuri__Multiply(struct soap *soap, const char *URL, struct __tempuri__Multiply *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read___tempuri__Multiply(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv___tempuri__Multiply(struct soap *soap, struct __tempuri__Multiply *p)
{
	if (soap_read___tempuri__Multiply(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE___tempuri__Subtract_DEFINED
#define SOAP_TYPE___tempuri__Subtract_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tempuri__Subtract(struct soap*, struct __tempuri__Subtract *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tempuri__Subtract(struct soap*, const struct __tempuri__Subtract *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tempuri__Subtract(struct soap*, const char*, int, const struct __tempuri__Subtract *, const char*);
SOAP_FMAC3 struct __tempuri__Subtract * SOAP_FMAC4 soap_in___tempuri__Subtract(struct soap*, const char*, struct __tempuri__Subtract *, const char*);
SOAP_FMAC1 struct __tempuri__Subtract * SOAP_FMAC2 soap_instantiate___tempuri__Subtract(struct soap*, int, const char*, const char*, size_t*);

inline struct __tempuri__Subtract * soap_new___tempuri__Subtract(struct soap *soap, int n = -1)
{
	return soap_instantiate___tempuri__Subtract(soap, n, NULL, NULL, NULL);
}

inline struct __tempuri__Subtract * soap_new_req___tempuri__Subtract(
	struct soap *soap)
{
	struct __tempuri__Subtract *_p = soap_new___tempuri__Subtract(soap);
	if (_p)
	{	soap_default___tempuri__Subtract(soap, _p);
	}
	return _p;
}

inline struct __tempuri__Subtract * soap_new_set___tempuri__Subtract(
	struct soap *soap,
	_mssamt__Subtract *mssamt__Subtract)
{
	struct __tempuri__Subtract *_p = soap_new___tempuri__Subtract(soap);
	if (_p)
	{	soap_default___tempuri__Subtract(soap, _p);
		_p->mssamt__Subtract = mssamt__Subtract;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tempuri__Subtract(struct soap*, const struct __tempuri__Subtract *, const char*, const char*);

inline int soap_write___tempuri__Subtract(struct soap *soap, struct __tempuri__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize___tempuri__Subtract(soap, p), 0) || soap_put___tempuri__Subtract(soap, p, "-tempuri:Subtract", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tempuri__Subtract(struct soap *soap, const char *URL, struct __tempuri__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize___tempuri__Subtract(soap, p), 0) || soap_put___tempuri__Subtract(soap, p, "-tempuri:Subtract", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send___tempuri__Subtract(struct soap *soap, const char *URL, struct __tempuri__Subtract const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize___tempuri__Subtract(soap, p), 0) || soap_put___tempuri__Subtract(soap, p, "-tempuri:Subtract", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct __tempuri__Subtract * SOAP_FMAC4 soap_get___tempuri__Subtract(struct soap*, struct __tempuri__Subtract *, const char*, const char*);

inline int soap_read___tempuri__Subtract(struct soap *soap, struct __tempuri__Subtract *p)
{
	if (p)
	{	soap_default___tempuri__Subtract(soap, p);
		if (soap_begin_recv(soap) || soap_get___tempuri__Subtract(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tempuri__Subtract(struct soap *soap, const char *URL, struct __tempuri__Subtract *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read___tempuri__Subtract(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv___tempuri__Subtract(struct soap *soap, struct __tempuri__Subtract *p)
{
	if (soap_read___tempuri__Subtract(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE___tempuri__Add_DEFINED
#define SOAP_TYPE___tempuri__Add_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_default___tempuri__Add(struct soap*, struct __tempuri__Add *);
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tempuri__Add(struct soap*, const struct __tempuri__Add *);
SOAP_FMAC3 int SOAP_FMAC4 soap_out___tempuri__Add(struct soap*, const char*, int, const struct __tempuri__Add *, const char*);
SOAP_FMAC3 struct __tempuri__Add * SOAP_FMAC4 soap_in___tempuri__Add(struct soap*, const char*, struct __tempuri__Add *, const char*);
SOAP_FMAC1 struct __tempuri__Add * SOAP_FMAC2 soap_instantiate___tempuri__Add(struct soap*, int, const char*, const char*, size_t*);

inline struct __tempuri__Add * soap_new___tempuri__Add(struct soap *soap, int n = -1)
{
	return soap_instantiate___tempuri__Add(soap, n, NULL, NULL, NULL);
}

inline struct __tempuri__Add * soap_new_req___tempuri__Add(
	struct soap *soap)
{
	struct __tempuri__Add *_p = soap_new___tempuri__Add(soap);
	if (_p)
	{	soap_default___tempuri__Add(soap, _p);
	}
	return _p;
}

inline struct __tempuri__Add * soap_new_set___tempuri__Add(
	struct soap *soap,
	_mssamt__Add *mssamt__Add)
{
	struct __tempuri__Add *_p = soap_new___tempuri__Add(soap);
	if (_p)
	{	soap_default___tempuri__Add(soap, _p);
		_p->mssamt__Add = mssamt__Add;
	}
	return _p;
}
SOAP_FMAC3 int SOAP_FMAC4 soap_put___tempuri__Add(struct soap*, const struct __tempuri__Add *, const char*, const char*);

inline int soap_write___tempuri__Add(struct soap *soap, struct __tempuri__Add const*p)
{
	soap_free_temp(soap);
	if (soap_begin_send(soap) || (soap_serialize___tempuri__Add(soap, p), 0) || soap_put___tempuri__Add(soap, p, "-tempuri:Add", "") || soap_end_send(soap))
			return soap->error;
	return SOAP_OK;
}

inline int soap_PUT___tempuri__Add(struct soap *soap, const char *URL, struct __tempuri__Add const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || (soap_serialize___tempuri__Add(soap, p), 0) || soap_put___tempuri__Add(soap, p, "-tempuri:Add", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send___tempuri__Add(struct soap *soap, const char *URL, struct __tempuri__Add const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || (soap_serialize___tempuri__Add(soap, p), 0) || soap_put___tempuri__Add(soap, p, "-tempuri:Add", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 struct __tempuri__Add * SOAP_FMAC4 soap_get___tempuri__Add(struct soap*, struct __tempuri__Add *, const char*, const char*);

inline int soap_read___tempuri__Add(struct soap *soap, struct __tempuri__Add *p)
{
	if (p)
	{	soap_default___tempuri__Add(soap, p);
		if (soap_begin_recv(soap) || soap_get___tempuri__Add(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET___tempuri__Add(struct soap *soap, const char *URL, struct __tempuri__Add *p)
{
	if (soap_GET(soap, URL, NULL) || soap_read___tempuri__Add(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv___tempuri__Add(struct soap *soap, struct __tempuri__Add *p)
{
	if (soap_read___tempuri__Add(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Reason_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap*, const char *, int, struct SOAP_ENV__Reason *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason **, const char*, const char*);
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Detail_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap*, const char *, int, struct SOAP_ENV__Detail *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail **, const char*, const char*);
#endif

#endif

#ifndef WITH_NOGLOBAL

#ifndef SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
#define SOAP_TYPE_PointerToSOAP_ENV__Code_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap*, const char *, int, struct SOAP_ENV__Code *const*, const char *);
SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*, const char*, const char*);
SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code **, const char*, const char*);
#endif

#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__DivideResponse_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__DivideResponse_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__DivideResponse(struct soap*, _mssamt__DivideResponse *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__DivideResponse(struct soap*, const char *, int, _mssamt__DivideResponse *const*, const char *);
SOAP_FMAC3 _mssamt__DivideResponse ** SOAP_FMAC4 soap_in_PointerTo_mssamt__DivideResponse(struct soap*, const char*, _mssamt__DivideResponse **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__DivideResponse(struct soap*, _mssamt__DivideResponse *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__DivideResponse ** SOAP_FMAC4 soap_get_PointerTo_mssamt__DivideResponse(struct soap*, _mssamt__DivideResponse **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__Divide_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__Divide_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__Divide(struct soap*, _mssamt__Divide *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__Divide(struct soap*, const char *, int, _mssamt__Divide *const*, const char *);
SOAP_FMAC3 _mssamt__Divide ** SOAP_FMAC4 soap_in_PointerTo_mssamt__Divide(struct soap*, const char*, _mssamt__Divide **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__Divide(struct soap*, _mssamt__Divide *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__Divide ** SOAP_FMAC4 soap_get_PointerTo_mssamt__Divide(struct soap*, _mssamt__Divide **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__MultiplyResponse_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__MultiplyResponse_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__MultiplyResponse(struct soap*, _mssamt__MultiplyResponse *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__MultiplyResponse(struct soap*, const char *, int, _mssamt__MultiplyResponse *const*, const char *);
SOAP_FMAC3 _mssamt__MultiplyResponse ** SOAP_FMAC4 soap_in_PointerTo_mssamt__MultiplyResponse(struct soap*, const char*, _mssamt__MultiplyResponse **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__MultiplyResponse(struct soap*, _mssamt__MultiplyResponse *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__MultiplyResponse ** SOAP_FMAC4 soap_get_PointerTo_mssamt__MultiplyResponse(struct soap*, _mssamt__MultiplyResponse **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__Multiply_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__Multiply_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__Multiply(struct soap*, _mssamt__Multiply *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__Multiply(struct soap*, const char *, int, _mssamt__Multiply *const*, const char *);
SOAP_FMAC3 _mssamt__Multiply ** SOAP_FMAC4 soap_in_PointerTo_mssamt__Multiply(struct soap*, const char*, _mssamt__Multiply **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__Multiply(struct soap*, _mssamt__Multiply *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__Multiply ** SOAP_FMAC4 soap_get_PointerTo_mssamt__Multiply(struct soap*, _mssamt__Multiply **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__SubtractResponse_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__SubtractResponse_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__SubtractResponse(struct soap*, _mssamt__SubtractResponse *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__SubtractResponse(struct soap*, const char *, int, _mssamt__SubtractResponse *const*, const char *);
SOAP_FMAC3 _mssamt__SubtractResponse ** SOAP_FMAC4 soap_in_PointerTo_mssamt__SubtractResponse(struct soap*, const char*, _mssamt__SubtractResponse **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__SubtractResponse(struct soap*, _mssamt__SubtractResponse *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__SubtractResponse ** SOAP_FMAC4 soap_get_PointerTo_mssamt__SubtractResponse(struct soap*, _mssamt__SubtractResponse **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__Subtract_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__Subtract_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__Subtract(struct soap*, _mssamt__Subtract *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__Subtract(struct soap*, const char *, int, _mssamt__Subtract *const*, const char *);
SOAP_FMAC3 _mssamt__Subtract ** SOAP_FMAC4 soap_in_PointerTo_mssamt__Subtract(struct soap*, const char*, _mssamt__Subtract **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__Subtract(struct soap*, _mssamt__Subtract *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__Subtract ** SOAP_FMAC4 soap_get_PointerTo_mssamt__Subtract(struct soap*, _mssamt__Subtract **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__AddResponse_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__AddResponse_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__AddResponse(struct soap*, _mssamt__AddResponse *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__AddResponse(struct soap*, const char *, int, _mssamt__AddResponse *const*, const char *);
SOAP_FMAC3 _mssamt__AddResponse ** SOAP_FMAC4 soap_in_PointerTo_mssamt__AddResponse(struct soap*, const char*, _mssamt__AddResponse **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__AddResponse(struct soap*, _mssamt__AddResponse *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__AddResponse ** SOAP_FMAC4 soap_get_PointerTo_mssamt__AddResponse(struct soap*, _mssamt__AddResponse **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTo_mssamt__Add_DEFINED
#define SOAP_TYPE_PointerTo_mssamt__Add_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_mssamt__Add(struct soap*, _mssamt__Add *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_mssamt__Add(struct soap*, const char *, int, _mssamt__Add *const*, const char *);
SOAP_FMAC3 _mssamt__Add ** SOAP_FMAC4 soap_in_PointerTo_mssamt__Add(struct soap*, const char*, _mssamt__Add **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_mssamt__Add(struct soap*, _mssamt__Add *const*, const char*, const char*);
SOAP_FMAC3 _mssamt__Add ** SOAP_FMAC4 soap_get_PointerTo_mssamt__Add(struct soap*, _mssamt__Add **, const char*, const char*);
#endif

#ifndef SOAP_TYPE_PointerTodouble_DEFINED
#define SOAP_TYPE_PointerTodouble_DEFINED
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTodouble(struct soap*, double *const*);
SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTodouble(struct soap*, const char *, int, double *const*, const char *);
SOAP_FMAC3 double ** SOAP_FMAC4 soap_in_PointerTodouble(struct soap*, const char*, double **, const char*);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTodouble(struct soap*, double *const*, const char*, const char*);
SOAP_FMAC3 double ** SOAP_FMAC4 soap_get_PointerTodouble(struct soap*, double **, const char*, const char*);
#endif

#ifndef SOAP_TYPE__QName_DEFINED
#define SOAP_TYPE__QName_DEFINED

inline void soap_default__QName(struct soap *soap, char **a)
{
	(void)soap; /* appease -Wall -Werror */
#ifdef SOAP_DEFAULT__QName
	*a = SOAP_DEFAULT__QName;
#else
	*a = (char *)0;
#endif
}
SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap*, char *const*);

#define soap__QName2s(soap, a) soap_QName2s(soap, (a))
SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2_QName(soap, s, a) soap_s2QName((soap), (s), (char**)(a), 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap*, const char*, char **, const char*);

SOAP_FMAC3 char * * SOAP_FMAC4 soap_new__QName(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap*, char *const*, const char*, const char*);

inline int soap_write__QName(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || soap_put__QName(soap, p, "QName", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT__QName(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || soap_put__QName(soap, p, "QName", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send__QName(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || soap_put__QName(soap, p, "QName", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap*, char **, const char*, const char*);

inline int soap_read__QName(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || soap_get__QName(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET__QName(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || soap_read__QName(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv__QName(struct soap *soap, char **p)
{
	if (soap_read__QName(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#ifndef SOAP_TYPE__XML_DEFINED
#define SOAP_TYPE__XML_DEFINED
#endif

#ifndef SOAP_TYPE_string_DEFINED
#define SOAP_TYPE_string_DEFINED

inline void 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*, char *const*);

#define soap_string2s(soap, a) (a)
SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap*, const char*, int, char*const*, const char*);

#define soap_s2string(soap, s, a) soap_s2char((soap), (s), (char**)(a), 1, 0, -1, NULL)
SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap*, const char*, char **, const char*);

SOAP_FMAC3 char * * SOAP_FMAC4 soap_new_string(struct soap *soap, int n = -1);
SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap*, char *const*, const char*, const char*);

inline int soap_write_string(struct soap *soap, char *const*p)
{
	soap_free_temp(soap);
	if (p)
	{	if (soap_begin_send(soap) || soap_put_string(soap, p, "string", "") || soap_end_send(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_PUT_string(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_PUT(soap, URL, NULL, NULL) || soap_put_string(soap, p, "string", "") || soap_end_send(soap) || soap_recv_empty_response(soap))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_send_string(struct soap *soap, const char *URL, char *const*p)
{
	soap_free_temp(soap);
	if (soap_connect(soap, URL, NULL) || soap_put_string(soap, p, "string", "") || soap_end_send(soap))
		return soap->error;
	return SOAP_OK;
}
SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap*, char **, const char*, const char*);

inline int soap_read_string(struct soap *soap, char **p)
{
	if (p)
	{	if (soap_begin_recv(soap) || soap_get_string(soap, p, NULL, NULL) == NULL || soap_end_recv(soap))
			return soap->error;
	}
	return SOAP_OK;
}

inline int soap_GET_string(struct soap *soap, const char *URL, char **p)
{
	if (soap_GET(soap, URL, NULL) || soap_read_string(soap, p))
		return soap->error;
	return SOAP_OK;
}

inline int soap_POST_recv_string(struct soap *soap, char **p)
{
	if (soap_read_string(soap, p) || soap_closesock(soap))
		return soap->error;
	return SOAP_OK;
}
#endif

#endif

/* End of soapH.h */
