/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.38
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGCSHARP


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif



#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL },
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_libsbml(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_libsbml(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_libsbml(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1 
#define  SWIG_IOError        	   -2 
#define  SWIG_RuntimeError   	   -3 
#define  SWIG_IndexError     	   -4 
#define  SWIG_TypeError      	   -5 
#define  SWIG_DivisionByZero 	   -6 
#define  SWIG_OverflowError  	   -7 
#define  SWIG_SyntaxError    	   -8 
#define  SWIG_ValueError     	   -9 
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12 
#define  SWIG_NullReferenceError   -13




/* Callback for returning strings to C# without leaking memory */
typedef void * (SWIGSTDCALL* SWIG_CSharpWStringHelperCallback)(const wchar_t *);
static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_callback = NULL;


#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_libsbml(SWIG_CSharpWStringHelperCallback callback) {
  SWIG_csharp_wstring_callback = callback;
}


#include "libsbml.h"
#ifdef USE_LAYOUT
#include "../swig/layout.h"
#endif /* USE_LAYOUT */
#include "local.cpp"


#include <string>


#include <string>


SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}


#include <stdexcept>


#include <iostream>
#include <fstream>
#include <sstream>


	
	class LIBLAX_EXTERN OStream 
	{
	protected:
		std::ostream* Stream;
		
	public:
		enum StdOSType {COUT,CERR,CLOG};
		
		/**
		 * Creates a new OStream object with one of standard output stream objects.
		 */
		OStream (StdOSType sot = COUT) 
		{
			switch (sot) {
				case COUT:
					Stream = &std::cout;
					break;
				case CERR:
					Stream = &std::cerr;
					break;
				case CLOG:
					Stream = &std::clog;
					break;
				default:
					Stream = &std::cout;
			}
		}
		
		virtual ~OStream () 
		{
		}
		
		/**
		 * Returns stream object.
		 */
		virtual std::ostream* get_ostream ()  
		{ 
			return Stream;
		}
		
		void endl ()
		{
			std::endl(*Stream);
		}
		
	};
	
	class LIBLAX_EXTERN OFStream : public OStream 
	{
	public:
		/**
		 * Creates a new OFStream object and opens a given file with 
		 * append flag (default is false) and associates its content 
		 * with stream object (Stream).
		 */
		OFStream (const std::string& filename, bool is_append = false) 
		{
			if (is_append) {
				Stream = new std::ofstream(filename.c_str(),ios_base::app);
			}
			else {
				Stream = new std::ofstream(filename.c_str(),ios_base::out);
			}
		}
		
		/**
		 * Opens a given file with append flag (default is false) and associates
		 * its content with existing stream object (Stream).
		 */
		void open (const std::string& filename, bool is_append = false) 
		{ 
			if (is_append) {
				static_cast<std::ofstream*>(Stream)->open(filename.c_str(),ios_base::app);
			}
			else {
				static_cast<std::ofstream*>(Stream)->open(filename.c_str(),ios_base::out);
			}
		}  
		
		/**
		 * Closes the file currently associated with stream object.
		 */
		void close ()
		{
			static_cast<std::ofstream*>(Stream)->close();
		}
		
		/**
		 * Returns true if stream object is currently associated with a file
		 */
		bool is_open () 
		{ 
			return static_cast<std::ofstream*>(Stream)->is_open(); 
		}
		
		virtual ~OFStream ()
		{
			delete Stream;
		}
		
	};
	
	class LIBLAX_EXTERN OStringStream : public OStream 
	{
	public:
		/**
		 * Creates a new OStringStream object
		 */
		OStringStream () 
		{
			Stream = new std::ostringstream();
		}
		
		/**
		 * Returns the copy of the string object currently assosiated 
		 * with the stream buffer.
		 */
		std::string str () 
		{
			return static_cast<std::ostringstream*>(Stream)->str();
		}
		
		/**
		 * Sets string s to the string object currently assosiated with 
		 * the stream buffer.
		 */
		void str (const std::string& s)
		{
			static_cast<std::ostringstream*>(Stream)->str(s.c_str());
		}
		
		virtual ~OStringStream () 
		{
			delete Stream;
		}
		
	};




#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void * SWIGSTDCALL CSharp_new_OStream__SWIG_0(int jarg1) {
  void * jresult ;
  OStream::StdOSType arg1 ;
  OStream *result = 0 ;
  
  arg1 = (OStream::StdOSType)jarg1; 
  result = (OStream *)new OStream(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_OStream__SWIG_1() {
  void * jresult ;
  OStream *result = 0 ;
  
  result = (OStream *)new OStream();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_OStream(void * jarg1) {
  OStream *arg1 = (OStream *) 0 ;
  
  arg1 = (OStream *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_OStream_get_ostream(void * jarg1) {
  void * jresult ;
  OStream *arg1 = (OStream *) 0 ;
  std::ostream *result = 0 ;
  
  arg1 = (OStream *)jarg1; 
  result = (std::ostream *)(arg1)->get_ostream();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_OStream_endl(void * jarg1) {
  OStream *arg1 = (OStream *) 0 ;
  
  arg1 = (OStream *)jarg1; 
  (arg1)->endl();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_OFStream__SWIG_0(wchar_t* jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  std::string arg_str1 ;
  OFStream *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToACP(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = jarg2 ? true : false; 
  result = (OFStream *)new OFStream((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_OFStream__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  OFStream *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToACP(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (OFStream *)new OFStream((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_OFStream_open__SWIG_0(void * jarg1, wchar_t* jarg2, unsigned int jarg3) {
  OFStream *arg1 = (OFStream *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  std::string arg_str2 ;
  
  arg1 = (OFStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToACP(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = jarg3 ? true : false; 
  (arg1)->open((std::string const &)*arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_OFStream_open__SWIG_1(void * jarg1, wchar_t* jarg2) {
  OFStream *arg1 = (OFStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (OFStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToACP(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->open((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_OFStream_close(void * jarg1) {
  OFStream *arg1 = (OFStream *) 0 ;
  
  arg1 = (OFStream *)jarg1; 
  (arg1)->close();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OFStream_is_open(void * jarg1) {
  unsigned int jresult ;
  OFStream *arg1 = (OFStream *) 0 ;
  bool result;
  
  arg1 = (OFStream *)jarg1; 
  result = (bool)(arg1)->is_open();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_OFStream(void * jarg1) {
  OFStream *arg1 = (OFStream *) 0 ;
  
  arg1 = (OFStream *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_OStringStream() {
  void * jresult ;
  OStringStream *result = 0 ;
  
  result = (OStringStream *)new OStringStream();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_OStringStream_str__SWIG_0(void * jarg1) {
  wchar_t* jresult ;
  OStringStream *arg1 = (OStringStream *) 0 ;
  std::string result;
  
  arg1 = (OStringStream *)jarg1; 
  result = (arg1)->str();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_OStringStream_str__SWIG_1(void * jarg1, wchar_t* jarg2) {
  OStringStream *arg1 = (OStringStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (OStringStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->str((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_OStringStream(void * jarg1) {
  OStringStream *arg1 = (OStringStream *) 0 ;
  
  arg1 = (OStringStream *)jarg1; 
  delete arg1;
}


SWIGEXPORT int SWIGSTDCALL CSharp_getLibSBMLVersion() {
  int jresult ;
  int result;
  
  result = (int)getLibSBMLVersion();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_getLibSBMLDottedVersion() {
  wchar_t* jresult ;
  char *result = 0 ;
  
  result = (char *)getLibSBMLDottedVersion();
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_getLibSBMLVersionString() {
  wchar_t* jresult ;
  char *result = 0 ;
  
  result = (char *)getLibSBMLVersionString();
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLReader() {
  void * jresult ;
  SBMLReader *result = 0 ;
  
  result = (SBMLReader *)new SBMLReader();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBMLReader(void * jarg1) {
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  
  arg1 = (SBMLReader *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLReader_readSBML(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SBMLDocument *result = 0 ;
  
  arg1 = (SBMLReader *)jarg1; 
  {
    char*  mbstr = convertUnicodeToACP(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SBMLDocument *)(arg1)->readSBML((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLReader_readSBMLFromString(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SBMLDocument *result = 0 ;
  
  arg1 = (SBMLReader *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SBMLDocument *)(arg1)->readSBMLFromString((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLReader_hasZlib() {
  unsigned int jresult ;
  bool result;
  
  result = (bool)SBMLReader::hasZlib();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLReader_hasBzip2() {
  unsigned int jresult ;
  bool result;
  
  result = (bool)SBMLReader::hasBzip2();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_readSBML(wchar_t* jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  SBMLDocument_t *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToACP(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (SBMLDocument_t *)readSBML((char const *)arg1);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_readSBMLFromString(wchar_t* jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  SBMLDocument_t *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (SBMLDocument_t *)readSBMLFromString((char const *)arg1);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLWriter() {
  void * jresult ;
  SBMLWriter *result = 0 ;
  
  result = (SBMLWriter *)new SBMLWriter();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBMLWriter(void * jarg1) {
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  
  arg1 = (SBMLWriter *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLWriter_setProgramName(void * jarg1, wchar_t* jarg2) {
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBMLWriter *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setProgramName((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLWriter_setProgramVersion(void * jarg1, wchar_t* jarg2) {
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBMLWriter *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setProgramVersion((std::string const &)*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLWriter_writeSBML__SWIG_0(void * jarg1, void * jarg2, wchar_t* jarg3) {
  unsigned int jresult ;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str3 ;
  bool result;
  
  arg1 = (SBMLWriter *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  {
    char*  mbstr = convertUnicodeToACP(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (bool)(arg1)->writeSBML((SBMLDocument const *)arg2,(std::string const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLWriter_writeSBML__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  std::ostream *arg3 = 0 ;
  bool result;
  
  arg1 = (SBMLWriter *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  arg3 = (std::ostream *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  result = (bool)(arg1)->writeSBML((SBMLDocument const *)arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBMLWriter_writeToString(void * jarg1, void * jarg2) {
  wchar_t* jresult ;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  char *result = 0 ;
  
  arg1 = (SBMLWriter *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  result = (char *)(arg1)->writeToString((SBMLDocument const *)arg2);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  free(result);
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLWriter_hasZlib() {
  unsigned int jresult ;
  bool result;
  
  result = (bool)SBMLWriter::hasZlib();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLWriter_hasBzip2() {
  unsigned int jresult ;
  bool result;
  
  result = (bool)SBMLWriter::hasBzip2();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_writeSBML(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  SBMLDocument_t *arg1 = (SBMLDocument_t *) 0 ;
  char *arg2 = (char *) 0 ;
  int result;
  
  arg1 = (SBMLDocument_t *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToACP(jarg2);
      if (!arg2) return 0;
    }
  }
  result = (int)writeSBML((SBMLDocument const *)arg1,(char const *)arg2);
  jresult = result; 
  {
    delete[] arg2;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_writeSBMLToString(void * jarg1) {
  wchar_t* jresult ;
  SBMLDocument_t *arg1 = (SBMLDocument_t *) 0 ;
  char *result = 0 ;
  
  arg1 = (SBMLDocument_t *)jarg1; 
  result = (char *)writeSBMLToString((SBMLDocument const *)arg1);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  free(result);
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBMLTypeCode_toString(int jarg1) {
  wchar_t* jresult ;
  SBMLTypeCode_t arg1 ;
  char *result = 0 ;
  
  arg1 = (SBMLTypeCode_t)jarg1; 
  result = (char *)SBMLTypeCode_toString(arg1);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBase(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_clone(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  SBase *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (SBase *)((SBase const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getMetaId(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  {
    std::string const &_result_ref = ((SBase const *)arg1)->getMetaId();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getId(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  {
    std::string const &_result_ref = ((SBase const *)arg1)->getId();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getName(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  {
    std::string const &_result_ref = ((SBase const *)arg1)->getName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getNotes(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNode *)(arg1)->getNotes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getNotesString(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string result;
  
  arg1 = (SBase *)jarg1; 
  result = (arg1)->getNotesString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getAnnotation(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNode *)(arg1)->getAnnotation();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getAnnotationString(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string result;
  
  arg1 = (SBase *)jarg1; 
  result = (arg1)->getAnnotationString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getNamespaces(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNamespaces *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNamespaces *)((SBase const *)arg1)->getNamespaces();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getSBMLDocument__SWIG_0(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  SBMLDocument *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (SBMLDocument *)((SBase const *)arg1)->getSBMLDocument();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getParentSBMLObject(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  SBase *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (SBase *)(arg1)->getParentSBMLObject();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getAncestorOfType(void * jarg1, int jarg2) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  SBMLTypeCode_t arg2 ;
  SBase *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (SBMLTypeCode_t)jarg2; 
  result = (SBase *)(arg1)->getAncestorOfType(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBase_getSBOTerm(void * jarg1) {
  int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  int result;
  
  arg1 = (SBase *)jarg1; 
  result = (int)((SBase const *)arg1)->getSBOTerm();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getSBOTermID(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string result;
  
  arg1 = (SBase *)jarg1; 
  result = ((SBase const *)arg1)->getSBOTermID();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_getLine(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int result;
  
  arg1 = (SBase *)jarg1; 
  result = (unsigned int)((SBase const *)arg1)->getLine();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_getColumn(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int result;
  
  arg1 = (SBase *)jarg1; 
  result = (unsigned int)((SBase const *)arg1)->getColumn();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetMetaId(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetMetaId();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetId(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetId();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetName(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetName();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetNotes(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetNotes();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetAnnotation(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetAnnotation();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_isSetSBOTerm(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  bool result;
  
  arg1 = (SBase *)jarg1; 
  result = (bool)((SBase const *)arg1)->isSetSBOTerm();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setMetaId(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setMetaId((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setId(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setId((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setName(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setName((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->setAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setAnnotation((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_appendAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->appendAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_appendAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->appendAnnotation((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setNotes__SWIG_0(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->setNotes((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setNotes__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setNotes((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_appendNotes__SWIG_0(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->appendNotes((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_appendNotes__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->appendNotes((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setSBMLDocument(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setParentSBMLObject(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setSBOTerm(void * jarg1, int jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->setSBOTerm(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_setNamespaces(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLNamespaces *)jarg2; 
  (arg1)->setNamespaces(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetMetaId(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetMetaId();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetId(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetId();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetName(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetName();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetNotes(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetNotes();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetAnnotation(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetAnnotation();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetSBOTerm(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetSBOTerm();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_addCVTerm(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (CVTerm *)jarg2; 
  (arg1)->addCVTerm(arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_getNumCVTerms(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int result;
  
  arg1 = (SBase *)jarg1; 
  result = (unsigned int)(arg1)->getNumCVTerms();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getCVTerm(void * jarg1, long long jarg2) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  CVTerm *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (CVTerm *)(arg1)->getCVTerm(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_unsetCVTerms(void * jarg1) {
  SBase *arg1 = (SBase *) 0 ;
  
  arg1 = (SBase *)jarg1; 
  (arg1)->unsetCVTerms();
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBase_getResourceBiologicalQualifier(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  BiolQualifierType_t result;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (BiolQualifierType_t)(arg1)->getResourceBiologicalQualifier(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBase_getResourceModelQualifier(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  ModelQualifierType_t result;
  
  arg1 = (SBase *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (ModelQualifierType_t)(arg1)->getResourceModelQualifier(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBase_getModel(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  Model *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (Model *)((SBase const *)arg1)->getModel();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_getLevel(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int result;
  
  arg1 = (SBase *)jarg1; 
  result = (unsigned int)((SBase const *)arg1)->getLevel();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBase_getVersion(void * jarg1) {
  unsigned int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int result;
  
  arg1 = (SBase *)jarg1; 
  result = (unsigned int)((SBase const *)arg1)->getVersion();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBase_getTypeCode(void * jarg1) {
  int jresult ;
  SBase *arg1 = (SBase *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (SBase *)jarg1; 
  result = (SBMLTypeCode_t)((SBase const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_getElementName(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  {
    std::string const &_result_ref = ((SBase const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBase_toSBML(void * jarg1) {
  wchar_t* jresult ;
  SBase *arg1 = (SBase *) 0 ;
  char *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (char *)(arg1)->toSBML();
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  free(result);
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_read(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLInputStream *arg2 = 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLInputStream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLInputStream & type is null", 0);
    return ;
  } 
  (arg1)->read(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBase_write(void * jarg1, void * jarg2) {
  SBase *arg1 = (SBase *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  
  arg1 = (SBase *)jarg1; 
  arg2 = (XMLOutputStream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLOutputStream & type is null", 0);
    return ;
  } 
  ((SBase const *)arg1)->write(*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOf__SWIG_0() {
  void * jresult ;
  ListOf *result = 0 ;
  
  result = (ListOf *)new ListOf();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOf(void * jarg1) {
  ListOf *arg1 = (ListOf *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOf__SWIG_1(void * jarg1) {
  void * jresult ;
  ListOf *arg1 = 0 ;
  ListOf *result = 0 ;
  
  arg1 = (ListOf *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ListOf const & type is null", 0);
    return 0;
  } 
  result = (ListOf *)new ListOf((ListOf const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOf_clone(void * jarg1) {
  void * jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  result = (SBase *)((ListOf const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_append(void * jarg1, void * jarg2) {
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->append((SBase const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_appendAndOwn(void * jarg1, void * jarg2) {
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->appendAndOwn(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOf_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int arg2 ;
  SBase *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBase *)((ListOf const *)arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOf_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SBase *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SBase *)((ListOf const *)arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_clear__SWIG_0(void * jarg1, unsigned int jarg2) {
  ListOf *arg1 = (ListOf *) 0 ;
  bool arg2 ;
  
  arg1 = (ListOf *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->clear(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_clear__SWIG_1(void * jarg1) {
  ListOf *arg1 = (ListOf *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOf_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int arg2 ;
  SBase *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBase *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOf_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SBase *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SBase *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ListOf_size(void * jarg1) {
  unsigned int jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int result;
  
  arg1 = (ListOf *)jarg1; 
  result = (unsigned int)((ListOf const *)arg1)->size();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_setSBMLDocument(void * jarg1, void * jarg2) {
  ListOf *arg1 = (ListOf *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ListOf_setParentSBMLObject(void * jarg1, void * jarg2) {
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (ListOf *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOf_getTypeCode(void * jarg1) {
  int jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOf *)jarg1; 
  result = (SBMLTypeCode_t)((ListOf const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOf_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOf *)jarg1; 
  result = (SBMLTypeCode_t)((ListOf const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOf_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOf *)jarg1; 
  {
    std::string const &_result_ref = ((ListOf const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Model *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Model *)new Model((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Model *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Model *)new Model((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_2() {
  void * jresult ;
  Model *result = 0 ;
  
  result = (Model *)new Model();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Model *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Model *)new Model(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Model *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Model *)new Model(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Model(void * jarg1) {
  Model *arg1 = (Model *) 0 ;
  
  arg1 = (Model *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Model__SWIG_5(void * jarg1) {
  void * jresult ;
  Model *arg1 = 0 ;
  Model *result = 0 ;
  
  arg1 = (Model *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Model const & type is null", 0);
    return 0;
  } 
  result = (Model *)new Model((Model const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_clone(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Model *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Model *)((Model const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getModelHistory__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ModelHistory *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ModelHistory *)((Model const *)arg1)->getModelHistory();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_isSetModelHistory(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  bool result;
  
  arg1 = (Model *)jarg1; 
  result = (bool)(arg1)->isSetModelHistory();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_setModelHistory(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  ModelHistory *arg2 = (ModelHistory *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (ModelHistory *)jarg2; 
  (arg1)->setModelHistory(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_unsetModelHistory(void * jarg1) {
  Model *arg1 = (Model *) 0 ;
  
  arg1 = (Model *)jarg1; 
  (arg1)->unsetModelHistory();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addFunctionDefinition(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  FunctionDefinition *arg2 = (FunctionDefinition *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (FunctionDefinition *)jarg2; 
  (arg1)->addFunctionDefinition((FunctionDefinition const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addUnitDefinition(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (UnitDefinition *)jarg2; 
  (arg1)->addUnitDefinition((UnitDefinition const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addCompartmentType(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  CompartmentType *arg2 = (CompartmentType *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (CompartmentType *)jarg2; 
  (arg1)->addCompartmentType((CompartmentType const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addSpeciesType(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  SpeciesType *arg2 = (SpeciesType *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (SpeciesType *)jarg2; 
  (arg1)->addSpeciesType((SpeciesType const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addCompartment(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Compartment *arg2 = (Compartment *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Compartment *)jarg2; 
  (arg1)->addCompartment((Compartment const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addSpecies(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Species *arg2 = (Species *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Species *)jarg2; 
  (arg1)->addSpecies((Species const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addParameter(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Parameter *arg2 = (Parameter *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Parameter *)jarg2; 
  (arg1)->addParameter((Parameter const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addInitialAssignment(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  InitialAssignment *arg2 = (InitialAssignment *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (InitialAssignment *)jarg2; 
  (arg1)->addInitialAssignment((InitialAssignment const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addRule(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Rule *arg2 = (Rule *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Rule *)jarg2; 
  (arg1)->addRule((Rule const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addConstraint(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Constraint *arg2 = (Constraint *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Constraint *)jarg2; 
  (arg1)->addConstraint((Constraint const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addReaction(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Reaction *arg2 = (Reaction *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Reaction *)jarg2; 
  (arg1)->addReaction((Reaction const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_addEvent(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  Event *arg2 = (Event *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (Event *)jarg2; 
  (arg1)->addEvent((Event const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createFunctionDefinition(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (FunctionDefinition *)(arg1)->createFunctionDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createUnitDefinition(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (UnitDefinition *)(arg1)->createUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createUnit(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Unit *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Unit *)(arg1)->createUnit();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createCompartmentType(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  CompartmentType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (CompartmentType *)(arg1)->createCompartmentType();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createSpeciesType(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  SpeciesType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (SpeciesType *)(arg1)->createSpeciesType();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createCompartment(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Compartment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Compartment *)(arg1)->createCompartment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createSpecies(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Species *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Species *)(arg1)->createSpecies();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createParameter(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Parameter *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Parameter *)(arg1)->createParameter();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createInitialAssignment(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (InitialAssignment *)(arg1)->createInitialAssignment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createAlgebraicRule(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  AlgebraicRule *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (AlgebraicRule *)(arg1)->createAlgebraicRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createAssignmentRule(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  AssignmentRule *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (AssignmentRule *)(arg1)->createAssignmentRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createRateRule(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  RateRule *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (RateRule *)(arg1)->createRateRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createConstraint(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Constraint *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Constraint *)(arg1)->createConstraint();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createReaction(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Reaction *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Reaction *)(arg1)->createReaction();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createReactant(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (SpeciesReference *)(arg1)->createReactant();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createProduct(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (SpeciesReference *)(arg1)->createProduct();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createModifier(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ModifierSpeciesReference *)(arg1)->createModifier();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createKineticLaw(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (KineticLaw *)(arg1)->createKineticLaw();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createKineticLawParameter(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Parameter *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Parameter *)(arg1)->createKineticLawParameter();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createEvent(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  Event *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (Event *)(arg1)->createEvent();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_createEventAssignment(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  EventAssignment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (EventAssignment *)(arg1)->createEventAssignment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_setAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->setAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_setAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setAnnotation((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_appendAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->appendAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_appendAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->appendAnnotation((std::string const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfFunctionDefinitions__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfFunctionDefinitions *)((Model const *)arg1)->getListOfFunctionDefinitions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfUnitDefinitions__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfUnitDefinitions *)((Model const *)arg1)->getListOfUnitDefinitions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfCompartmentTypes__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfCompartmentTypes *)((Model const *)arg1)->getListOfCompartmentTypes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfSpeciesTypes__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfSpeciesTypes *)((Model const *)arg1)->getListOfSpeciesTypes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfCompartments__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfCompartments *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfCompartments *)((Model const *)arg1)->getListOfCompartments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfSpecies__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfSpecies *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfSpecies *)((Model const *)arg1)->getListOfSpecies();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfParameters__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfParameters *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfParameters *)((Model const *)arg1)->getListOfParameters();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfInitialAssignments__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfInitialAssignments *)((Model const *)arg1)->getListOfInitialAssignments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfRules__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfRules *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfRules *)((Model const *)arg1)->getListOfRules();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfConstraints__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfConstraints *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfConstraints *)((Model const *)arg1)->getListOfConstraints();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfReactions__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfReactions *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfReactions *)((Model const *)arg1)->getListOfReactions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getListOfEvents__SWIG_0(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  ListOfEvents *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (ListOfEvents *)((Model const *)arg1)->getListOfEvents();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getFunctionDefinition__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (FunctionDefinition *)((Model const *)arg1)->getFunctionDefinition(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getFunctionDefinition__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (FunctionDefinition *)((Model const *)arg1)->getFunctionDefinition((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getUnitDefinition__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (UnitDefinition *)((Model const *)arg1)->getUnitDefinition(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getUnitDefinition__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (UnitDefinition *)((Model const *)arg1)->getUnitDefinition((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getCompartmentType__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (CompartmentType *)((Model const *)arg1)->getCompartmentType(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getCompartmentType__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (CompartmentType *)((Model const *)arg1)->getCompartmentType((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getSpeciesType__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesType *)((Model const *)arg1)->getSpeciesType(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getSpeciesType__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesType *)((Model const *)arg1)->getSpeciesType((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getCompartment__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Compartment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Compartment *)((Model const *)arg1)->getCompartment(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getCompartment__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Compartment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Compartment *)((Model const *)arg1)->getCompartment((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getSpecies__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Species *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Species *)((Model const *)arg1)->getSpecies(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getSpecies__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Species *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Species *)((Model const *)arg1)->getSpecies((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getParameter__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Parameter *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Parameter *)((Model const *)arg1)->getParameter(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getParameter__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Parameter *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Parameter *)((Model const *)arg1)->getParameter((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getInitialAssignment__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (InitialAssignment *)((Model const *)arg1)->getInitialAssignment(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getInitialAssignment__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (InitialAssignment *)((Model const *)arg1)->getInitialAssignment((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getRule__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Rule *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Rule *)((Model const *)arg1)->getRule(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getRule__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Rule *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Rule *)((Model const *)arg1)->getRule((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getConstraint__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Constraint *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Constraint *)((Model const *)arg1)->getConstraint(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getReaction__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Reaction *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Reaction *)((Model const *)arg1)->getReaction(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getReaction__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Reaction *)((Model const *)arg1)->getReaction((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getEvent__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  Event *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Event *)((Model const *)arg1)->getEvent(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Model_getEvent__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Event *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Event *)((Model const *)arg1)->getEvent((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumFunctionDefinitions(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumFunctionDefinitions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumUnitDefinitions(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumUnitDefinitions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumCompartmentTypes(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumCompartmentTypes();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumSpeciesTypes(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumSpeciesTypes();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumCompartments(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumCompartments();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumSpecies(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumSpecies();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumSpeciesWithBoundaryCondition(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumSpeciesWithBoundaryCondition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumParameters(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumParameters();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumInitialAssignments(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumInitialAssignments();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumRules(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumRules();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumConstraints(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumConstraints();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumReactions(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumReactions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_getNumEvents(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  unsigned int result;
  
  arg1 = (Model *)jarg1; 
  result = (unsigned int)((Model const *)arg1)->getNumEvents();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_convertToL1(void * jarg1) {
  Model *arg1 = (Model *) 0 ;
  
  arg1 = (Model *)jarg1; 
  (arg1)->convertToL1();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_convertToL2(void * jarg1) {
  Model *arg1 = (Model *) 0 ;
  
  arg1 = (Model *)jarg1; 
  (arg1)->convertToL2();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_isBoolean(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (Model *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  result = (bool)((Model const *)arg1)->isBoolean((ASTNode const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_setSBMLDocument(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_setParentSBMLObject(void * jarg1, void * jarg2) {
  Model *arg1 = (Model *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (Model *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Model_getTypeCode(void * jarg1) {
  int jresult ;
  Model *arg1 = (Model *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Model *)jarg1; 
  result = (SBMLTypeCode_t)((Model const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Model_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Model *arg1 = (Model *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  {
    std::string const &_result_ref = ((Model const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Model_populateListFormulaUnitsData(void * jarg1) {
  Model *arg1 = (Model *) 0 ;
  
  arg1 = (Model *)jarg1; 
  (arg1)->populateListFormulaUnitsData();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Model_isPopulatedListFormulaUnitsData(void * jarg1) {
  unsigned int jresult ;
  Model *arg1 = (Model *) 0 ;
  bool result;
  
  arg1 = (Model *)jarg1; 
  result = (bool)(arg1)->isPopulatedListFormulaUnitsData();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_getDefaultLevel() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)SBMLDocument::getDefaultLevel();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_getDefaultVersion() {
  unsigned int jresult ;
  unsigned int result;
  
  result = (unsigned int)SBMLDocument::getDefaultVersion();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLDocument__SWIG_0(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  SBMLDocument *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBMLDocument *)new SBMLDocument(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLDocument__SWIG_1(long long jarg1) {
  void * jresult ;
  unsigned int arg1 ;
  SBMLDocument *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (SBMLDocument *)new SBMLDocument(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLDocument__SWIG_2() {
  void * jresult ;
  SBMLDocument *result = 0 ;
  
  result = (SBMLDocument *)new SBMLDocument();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBMLDocument(void * jarg1) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLDocument__SWIG_3(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = 0 ;
  SBMLDocument *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SBMLDocument const & type is null", 0);
    return 0;
  } 
  result = (SBMLDocument *)new SBMLDocument((SBMLDocument const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_clone(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLDocument *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (SBMLDocument *)((SBMLDocument const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_getModel__SWIG_0(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  Model *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (Model *)((SBMLDocument const *)arg1)->getModel();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_setLevelAndVersion(void * jarg1, long long jarg2, long long jarg3) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bool result;
  
  arg1 = (SBMLDocument *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (bool)(arg1)->setLevelAndVersion(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLDocument_setModel(void * jarg1, void * jarg2) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  Model *arg2 = (Model *) 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  arg2 = (Model *)jarg2; 
  (arg1)->setModel((Model const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_createModel__SWIG_0(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Model *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Model *)(arg1)->createModel((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_createModel__SWIG_1(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  Model *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (Model *)(arg1)->createModel();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLDocument_setConsistencyChecks(void * jarg1, int jarg2, unsigned int jarg3) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLErrorCategory_t arg2 ;
  bool arg3 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  arg2 = (SBMLErrorCategory_t)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->setConsistencyChecks(arg2,arg3);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkConsistency(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkConsistency();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkInternalConsistency(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkInternalConsistency();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkL1Compatibility(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkL1Compatibility();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkL2v1Compatibility(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkL2v1Compatibility();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkL2v2Compatibility(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkL2v2Compatibility();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkL2v3Compatibility(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkL2v3Compatibility();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_checkL2v4Compatibility(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)(arg1)->checkL2v4Compatibility();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_getError(void * jarg1, long long jarg2) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  SBMLError *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBMLError *)((SBMLDocument const *)arg1)->getError(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLDocument_getNumErrors(void * jarg1) {
  unsigned int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (unsigned int)((SBMLDocument const *)arg1)->getNumErrors();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLDocument_printErrors__SWIG_0(void * jarg1, void * jarg2) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::ostream *arg2 = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  arg2 = (std::ostream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return ;
  } 
  ((SBMLDocument const *)arg1)->printErrors(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLDocument_printErrors__SWIG_1(void * jarg1) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  ((SBMLDocument const *)arg1)->printErrors();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLDocument_setSBMLDocument(void * jarg1, void * jarg2) {
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBMLDocument_getTypeCode(void * jarg1) {
  int jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (SBMLTypeCode_t)((SBMLDocument const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBMLDocument_getElementName(void * jarg1) {
  wchar_t* jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  {
    std::string const &_result_ref = ((SBMLDocument const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_getErrorLog(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLErrorLog *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (SBMLErrorLog *)(arg1)->getErrorLog();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLDocument_getNamespaces(void * jarg1) {
  void * jresult ;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  XMLNamespaces *result = 0 ;
  
  arg1 = (SBMLDocument *)jarg1; 
  result = (XMLNamespaces *)((SBMLDocument const *)arg1)->getNamespaces();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  FunctionDefinition *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (FunctionDefinition *)new FunctionDefinition((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  FunctionDefinition *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (FunctionDefinition *)new FunctionDefinition((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_2() {
  void * jresult ;
  FunctionDefinition *result = 0 ;
  
  result = (FunctionDefinition *)new FunctionDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  FunctionDefinition *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (FunctionDefinition *)new FunctionDefinition(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  FunctionDefinition *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (FunctionDefinition *)new FunctionDefinition(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_5(wchar_t* jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  std::string arg_str1 ;
  FunctionDefinition *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (ASTNode *)jarg2; 
  result = (FunctionDefinition *)new FunctionDefinition((std::string const &)*arg1,(ASTNode const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_FunctionDefinition(void * jarg1) {
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FunctionDefinition__SWIG_6(void * jarg1) {
  void * jresult ;
  FunctionDefinition *arg1 = 0 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FunctionDefinition const & type is null", 0);
    return 0;
  } 
  result = (FunctionDefinition *)new FunctionDefinition((FunctionDefinition const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FunctionDefinition_clone(void * jarg1) {
  void * jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (FunctionDefinition *)((FunctionDefinition const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FunctionDefinition_getMath(void * jarg1) {
  void * jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FunctionDefinition_isSetMath(void * jarg1) {
  unsigned int jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  bool result;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (bool)((FunctionDefinition const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_FunctionDefinition_setMath(void * jarg1, void * jarg2) {
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FunctionDefinition_getArgument__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  unsigned int arg2 ;
  ASTNode *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getArgument(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FunctionDefinition_getArgument__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  ASTNode *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getArgument((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_FunctionDefinition_getBody__SWIG_0(void * jarg1) {
  void * jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getBody();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FunctionDefinition_getNumArguments(void * jarg1) {
  unsigned int jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  unsigned int result;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (unsigned int)((FunctionDefinition const *)arg1)->getNumArguments();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_FunctionDefinition_getTypeCode(void * jarg1) {
  int jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (FunctionDefinition *)jarg1; 
  result = (SBMLTypeCode_t)((FunctionDefinition const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_FunctionDefinition_getElementName(void * jarg1) {
  wchar_t* jresult ;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (FunctionDefinition *)jarg1; 
  {
    std::string const &_result_ref = ((FunctionDefinition const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfFunctionDefinitions_clone(void * jarg1) {
  void * jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  result = (ListOfFunctionDefinitions *)((ListOfFunctionDefinitions const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfFunctionDefinitions_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfFunctionDefinitions const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfFunctionDefinitions_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfFunctionDefinitions const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfFunctionDefinitions_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfFunctionDefinitions const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfFunctionDefinitions_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  unsigned int arg2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (FunctionDefinition *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfFunctionDefinitions_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (FunctionDefinition *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfFunctionDefinitions_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  unsigned int arg2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (FunctionDefinition *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfFunctionDefinitions_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  FunctionDefinition *result = 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (FunctionDefinition *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfFunctionDefinitions() {
  void * jresult ;
  ListOfFunctionDefinitions *result = 0 ;
  
  result = (ListOfFunctionDefinitions *)new ListOfFunctionDefinitions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfFunctionDefinitions(void * jarg1) {
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  
  arg1 = (ListOfFunctionDefinitions *)jarg1; 
  delete arg1;
}


SWIGEXPORT int SWIGSTDCALL CSharp_UnitKind_equals(int jarg1, int jarg2) {
  int jresult ;
  UnitKind_t arg1 ;
  UnitKind_t arg2 ;
  int result;
  
  arg1 = (UnitKind_t)jarg1; 
  arg2 = (UnitKind_t)jarg2; 
  result = (int)UnitKind_equals(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_UnitKind_forName(wchar_t* jarg1) {
  int jresult ;
  char *arg1 = (char *) 0 ;
  UnitKind_t result;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (UnitKind_t)UnitKind_forName((char const *)arg1);
  jresult = result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_UnitKind_toString(int jarg1) {
  wchar_t* jresult ;
  UnitKind_t arg1 ;
  char *result = 0 ;
  
  arg1 = (UnitKind_t)jarg1; 
  result = (char *)UnitKind_toString(arg1);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_UnitKind_isValidUnitKindString(wchar_t* jarg1, long long jarg2, long long jarg3) {
  int jresult ;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int result;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (int)UnitKind_isValidUnitKindString((char const *)arg1,arg2,arg3);
  jresult = result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_0(int jarg1, int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  UnitKind_t arg1 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  Unit *result = 0 ;
  
  arg1 = (UnitKind_t)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (double)jarg4; 
  result = (Unit *)new Unit(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_1(int jarg1, int jarg2, int jarg3) {
  void * jresult ;
  UnitKind_t arg1 ;
  int arg2 ;
  int arg3 ;
  Unit *result = 0 ;
  
  arg1 = (UnitKind_t)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (Unit *)new Unit(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_2(int jarg1, int jarg2) {
  void * jresult ;
  UnitKind_t arg1 ;
  int arg2 ;
  Unit *result = 0 ;
  
  arg1 = (UnitKind_t)jarg1; 
  arg2 = (int)jarg2; 
  result = (Unit *)new Unit(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_3(int jarg1) {
  void * jresult ;
  UnitKind_t arg1 ;
  Unit *result = 0 ;
  
  arg1 = (UnitKind_t)jarg1; 
  result = (Unit *)new Unit(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_4() {
  void * jresult ;
  Unit *result = 0 ;
  
  result = (Unit *)new Unit();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_5(wchar_t* jarg1, int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  std::string arg_str1 ;
  Unit *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (double)jarg4; 
  result = (Unit *)new Unit((std::string const &)*arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_6(wchar_t* jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  std::string arg_str1 ;
  Unit *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (Unit *)new Unit((std::string const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_7(wchar_t* jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::string arg_str1 ;
  Unit *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (int)jarg2; 
  result = (Unit *)new Unit((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_8(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Unit *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Unit *)new Unit((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_9(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Unit *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Unit *)new Unit(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_10(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Unit *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Unit *)new Unit(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Unit(void * jarg1) {
  Unit *arg1 = (Unit *) 0 ;
  
  arg1 = (Unit *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Unit__SWIG_11(void * jarg1) {
  void * jresult ;
  Unit *arg1 = 0 ;
  Unit *result = 0 ;
  
  arg1 = (Unit *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unit const & type is null", 0);
    return 0;
  } 
  result = (Unit *)new Unit((Unit const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Unit_clone(void * jarg1) {
  void * jresult ;
  Unit *arg1 = (Unit *) 0 ;
  Unit *result = 0 ;
  
  arg1 = (Unit *)jarg1; 
  result = (Unit *)((Unit const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_initDefaults(void * jarg1) {
  Unit *arg1 = (Unit *) 0 ;
  
  arg1 = (Unit *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT int SWIGSTDCALL CSharp_Unit_getKind(void * jarg1) {
  int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  UnitKind_t result;
  
  arg1 = (Unit *)jarg1; 
  result = (UnitKind_t)((Unit const *)arg1)->getKind();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Unit_getExponent(void * jarg1) {
  int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  int result;
  
  arg1 = (Unit *)jarg1; 
  result = (int)((Unit const *)arg1)->getExponent();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Unit_getScale(void * jarg1) {
  int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  int result;
  
  arg1 = (Unit *)jarg1; 
  result = (int)((Unit const *)arg1)->getScale();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Unit_getMultiplier(void * jarg1) {
  double jresult ;
  Unit *arg1 = (Unit *) 0 ;
  double result;
  
  arg1 = (Unit *)jarg1; 
  result = (double)((Unit const *)arg1)->getMultiplier();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Unit_getOffset(void * jarg1) {
  double jresult ;
  Unit *arg1 = (Unit *) 0 ;
  double result;
  
  arg1 = (Unit *)jarg1; 
  result = (double)((Unit const *)arg1)->getOffset();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isAmpere(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isAmpere();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isBecquerel(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isBecquerel();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isCandela(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isCandela();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isCelsius(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isCelsius();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isCoulomb(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isCoulomb();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isDimensionless(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isDimensionless();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isFarad(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isFarad();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isGram(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isGram();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isGray(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isGray();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isHenry(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isHenry();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isHertz(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isHertz();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isItem(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isItem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isJoule(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isJoule();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isKatal(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isKatal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isKelvin(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isKelvin();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isKilogram(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isKilogram();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isLitre(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isLitre();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isLumen(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isLumen();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isLux(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isLux();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isMetre(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isMetre();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isMole(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isMole();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isNewton(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isNewton();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isOhm(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isOhm();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isPascal(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isPascal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isRadian(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isRadian();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isSecond(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isSecond();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isSiemens(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isSiemens();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isSievert(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isSievert();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isSteradian(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isSteradian();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isTesla(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isTesla();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isVolt(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isVolt();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isWatt(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isWatt();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isWeber(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isWeber();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isSetKind(void * jarg1) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  result = (bool)((Unit const *)arg1)->isSetKind();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_setKind(void * jarg1, int jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  UnitKind_t arg2 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (UnitKind_t)jarg2; 
  (arg1)->setKind(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_setExponent(void * jarg1, int jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  int arg2 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->setExponent(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_setScale(void * jarg1, int jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  int arg2 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->setScale(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_setMultiplier(void * jarg1, double jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setMultiplier(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_setOffset(void * jarg1, double jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setOffset(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Unit_getTypeCode(void * jarg1) {
  int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Unit *)jarg1; 
  result = (SBMLTypeCode_t)((Unit const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Unit_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Unit *arg1 = (Unit *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Unit *)jarg1; 
  {
    std::string const &_result_ref = ((Unit const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isBuiltIn(wchar_t* jarg1, long long jarg2) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  std::string arg_str1 ;
  bool result;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (bool)Unit::isBuiltIn((std::string const &)*arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_isUnitKind(wchar_t* jarg1, long long jarg2, long long jarg3) {
  unsigned int jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg_str1 ;
  bool result;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (bool)Unit::isUnitKind((std::string const &)*arg1,arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_areIdentical(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (Unit *)jarg2; 
  result = (bool)Unit::areIdentical(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Unit_areEquivalent(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  bool result;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (Unit *)jarg2; 
  result = (bool)Unit::areEquivalent(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_removeScale(void * jarg1) {
  Unit *arg1 = (Unit *) 0 ;
  
  arg1 = (Unit *)jarg1; 
  Unit::removeScale(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Unit_merge(void * jarg1, void * jarg2) {
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  
  arg1 = (Unit *)jarg1; 
  arg2 = (Unit *)jarg2; 
  Unit::merge(arg1,arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Unit_convertToSI(void * jarg1) {
  void * jresult ;
  Unit *arg1 = (Unit *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Unit *)jarg1; 
  result = (UnitDefinition *)Unit::convertToSI((Unit const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnits_clone(void * jarg1) {
  void * jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  ListOfUnits *result = 0 ;
  
  arg1 = (ListOfUnits *)jarg1; 
  result = (ListOfUnits *)((ListOfUnits const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfUnits_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfUnits *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfUnits const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfUnits_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfUnits *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfUnits const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfUnits_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfUnits *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfUnits const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnits_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  unsigned int arg2 ;
  Unit *result = 0 ;
  
  arg1 = (ListOfUnits *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Unit *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnits_remove(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  unsigned int arg2 ;
  Unit *result = 0 ;
  
  arg1 = (ListOfUnits *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Unit *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfUnits() {
  void * jresult ;
  ListOfUnits *result = 0 ;
  
  result = (ListOfUnits *)new ListOfUnits();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfUnits(void * jarg1) {
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  
  arg1 = (ListOfUnits *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  UnitDefinition *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (UnitDefinition *)new UnitDefinition((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  UnitDefinition *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (UnitDefinition *)new UnitDefinition((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_2() {
  void * jresult ;
  UnitDefinition *result = 0 ;
  
  result = (UnitDefinition *)new UnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  UnitDefinition *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (UnitDefinition *)new UnitDefinition(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  UnitDefinition *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (UnitDefinition *)new UnitDefinition(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_UnitDefinition(void * jarg1) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_UnitDefinition__SWIG_5(void * jarg1) {
  void * jresult ;
  UnitDefinition *arg1 = 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "UnitDefinition const & type is null", 0);
    return 0;
  } 
  result = (UnitDefinition *)new UnitDefinition((UnitDefinition const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_clone(void * jarg1) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (UnitDefinition *)((UnitDefinition const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfArea(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfArea();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfLength(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfSubstance(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstance();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfTime(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfVolume(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfDimensionless(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfDimensionless();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfMass(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfMass();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_isVariantOfSubstancePerTime(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstancePerTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UnitDefinition_addUnit(void * jarg1, void * jarg2) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (Unit *)jarg2; 
  (arg1)->addUnit((Unit const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_createUnit(void * jarg1) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  Unit *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (Unit *)(arg1)->createUnit();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_getListOfUnits__SWIG_0(void * jarg1) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  ListOfUnits *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (ListOfUnits *)((UnitDefinition const *)arg1)->getListOfUnits();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_getUnit__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  unsigned int arg2 ;
  Unit *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Unit *)(arg1)->getUnit(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_getNumUnits(void * jarg1) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  unsigned int result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (unsigned int)((UnitDefinition const *)arg1)->getNumUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UnitDefinition_setSBMLDocument(void * jarg1, void * jarg2) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_UnitDefinition_setParentSBMLObject(void * jarg1, void * jarg2) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_UnitDefinition_getTypeCode(void * jarg1) {
  int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (SBMLTypeCode_t)((UnitDefinition const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_UnitDefinition_getElementName(void * jarg1) {
  wchar_t* jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  {
    std::string const &_result_ref = ((UnitDefinition const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_UnitDefinition_simplify(void * jarg1) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  UnitDefinition::simplify(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_UnitDefinition_reorder(void * jarg1) {
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  UnitDefinition::reorder(arg1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_convertToSI(void * jarg1) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = (UnitDefinition *)UnitDefinition::convertToSI((UnitDefinition const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_areIdentical(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (UnitDefinition *)jarg2; 
  result = (bool)UnitDefinition::areIdentical((UnitDefinition const *)arg1,(UnitDefinition const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_UnitDefinition_areEquivalent(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  bool result;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (UnitDefinition *)jarg2; 
  result = (bool)UnitDefinition::areEquivalent((UnitDefinition const *)arg1,(UnitDefinition const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_UnitDefinition_combine(void * jarg1, void * jarg2) {
  void * jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = (UnitDefinition *)jarg2; 
  result = (UnitDefinition *)UnitDefinition::combine(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_UnitDefinition_printUnits__SWIG_0(void * jarg1, unsigned int jarg2) {
  wchar_t* jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (UnitDefinition *)jarg1; 
  arg2 = jarg2 ? true : false; 
  result = UnitDefinition::printUnits((UnitDefinition const *)arg1,arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_UnitDefinition_printUnits__SWIG_1(void * jarg1) {
  wchar_t* jresult ;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string result;
  
  arg1 = (UnitDefinition *)jarg1; 
  result = UnitDefinition::printUnits((UnitDefinition const *)arg1);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnitDefinitions_clone(void * jarg1) {
  void * jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  result = (ListOfUnitDefinitions *)((ListOfUnitDefinitions const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfUnitDefinitions_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfUnitDefinitions const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfUnitDefinitions_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfUnitDefinitions const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfUnitDefinitions_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfUnitDefinitions const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnitDefinitions_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  unsigned int arg2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (UnitDefinition *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnitDefinitions_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (UnitDefinition *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnitDefinitions_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  unsigned int arg2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (UnitDefinition *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfUnitDefinitions_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (UnitDefinition *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfUnitDefinitions() {
  void * jresult ;
  ListOfUnitDefinitions *result = 0 ;
  
  result = (ListOfUnitDefinitions *)new ListOfUnitDefinitions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfUnitDefinitions(void * jarg1) {
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  
  arg1 = (ListOfUnitDefinitions *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  CompartmentType *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (CompartmentType *)new CompartmentType((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  CompartmentType *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (CompartmentType *)new CompartmentType((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_2() {
  void * jresult ;
  CompartmentType *result = 0 ;
  
  result = (CompartmentType *)new CompartmentType();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  CompartmentType *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (CompartmentType *)new CompartmentType(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  CompartmentType *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (CompartmentType *)new CompartmentType(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CompartmentType(void * jarg1) {
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  
  arg1 = (CompartmentType *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CompartmentType__SWIG_5(void * jarg1) {
  void * jresult ;
  CompartmentType *arg1 = 0 ;
  CompartmentType *result = 0 ;
  
  arg1 = (CompartmentType *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CompartmentType const & type is null", 0);
    return 0;
  } 
  result = (CompartmentType *)new CompartmentType((CompartmentType const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_CompartmentType_clone(void * jarg1) {
  void * jresult ;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  CompartmentType *result = 0 ;
  
  arg1 = (CompartmentType *)jarg1; 
  result = (CompartmentType *)((CompartmentType const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CompartmentType_getTypeCode(void * jarg1) {
  int jresult ;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (CompartmentType *)jarg1; 
  result = (SBMLTypeCode_t)((CompartmentType const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_CompartmentType_getElementName(void * jarg1) {
  wchar_t* jresult ;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (CompartmentType *)jarg1; 
  {
    std::string const &_result_ref = ((CompartmentType const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartmentTypes_clone(void * jarg1) {
  void * jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  result = (ListOfCompartmentTypes *)((ListOfCompartmentTypes const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfCompartmentTypes_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfCompartmentTypes const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfCompartmentTypes_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfCompartmentTypes const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfCompartmentTypes_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfCompartmentTypes const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartmentTypes_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  unsigned int arg2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (CompartmentType *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartmentTypes_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (CompartmentType *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartmentTypes_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  unsigned int arg2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (CompartmentType *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartmentTypes_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  CompartmentType *result = 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (CompartmentType *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfCompartmentTypes() {
  void * jresult ;
  ListOfCompartmentTypes *result = 0 ;
  
  result = (ListOfCompartmentTypes *)new ListOfCompartmentTypes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfCompartmentTypes(void * jarg1) {
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  
  arg1 = (ListOfCompartmentTypes *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  SpeciesType *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesType *)new SpeciesType((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  SpeciesType *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (SpeciesType *)new SpeciesType((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_2() {
  void * jresult ;
  SpeciesType *result = 0 ;
  
  result = (SpeciesType *)new SpeciesType();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  SpeciesType *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (SpeciesType *)new SpeciesType(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  SpeciesType *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesType *)new SpeciesType(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SpeciesType(void * jarg1) {
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  
  arg1 = (SpeciesType *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesType__SWIG_5(void * jarg1) {
  void * jresult ;
  SpeciesType *arg1 = 0 ;
  SpeciesType *result = 0 ;
  
  arg1 = (SpeciesType *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SpeciesType const & type is null", 0);
    return 0;
  } 
  result = (SpeciesType *)new SpeciesType((SpeciesType const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SpeciesType_clone(void * jarg1) {
  void * jresult ;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  SpeciesType *result = 0 ;
  
  arg1 = (SpeciesType *)jarg1; 
  result = (SpeciesType *)((SpeciesType const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SpeciesType_getTypeCode(void * jarg1) {
  int jresult ;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (SpeciesType *)jarg1; 
  result = (SBMLTypeCode_t)((SpeciesType const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SpeciesType_getElementName(void * jarg1) {
  wchar_t* jresult ;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SpeciesType *)jarg1; 
  {
    std::string const &_result_ref = ((SpeciesType const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesTypes_clone(void * jarg1) {
  void * jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  result = (ListOfSpeciesTypes *)((ListOfSpeciesTypes const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpeciesTypes_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpeciesTypes const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpeciesTypes_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpeciesTypes const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfSpeciesTypes_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfSpeciesTypes const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesTypes_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  unsigned int arg2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesType *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesTypes_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesType *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesTypes_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  unsigned int arg2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesType *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesTypes_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SpeciesType *result = 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesType *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfSpeciesTypes() {
  void * jresult ;
  ListOfSpeciesTypes *result = 0 ;
  
  result = (ListOfSpeciesTypes *)new ListOfSpeciesTypes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfSpeciesTypes(void * jarg1) {
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  
  arg1 = (ListOfSpeciesTypes *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Compartment *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Compartment *)new Compartment((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Compartment *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Compartment *)new Compartment((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_2() {
  void * jresult ;
  Compartment *result = 0 ;
  
  result = (Compartment *)new Compartment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Compartment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Compartment *)new Compartment(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Compartment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Compartment *)new Compartment(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Compartment(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Compartment__SWIG_5(void * jarg1) {
  void * jresult ;
  Compartment *arg1 = 0 ;
  Compartment *result = 0 ;
  
  arg1 = (Compartment *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Compartment const & type is null", 0);
    return 0;
  } 
  result = (Compartment *)new Compartment((Compartment const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Compartment_clone(void * jarg1) {
  void * jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  Compartment *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  result = (Compartment *)((Compartment const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_initDefaults(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Compartment_getCompartmentType(void * jarg1) {
  wchar_t* jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    std::string const &_result_ref = ((Compartment const *)arg1)->getCompartmentType();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_getSpatialDimensions(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  unsigned int result;
  
  arg1 = (Compartment *)jarg1; 
  result = (unsigned int)((Compartment const *)arg1)->getSpatialDimensions();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Compartment_getSize(void * jarg1) {
  double jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  double result;
  
  arg1 = (Compartment *)jarg1; 
  result = (double)((Compartment const *)arg1)->getSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Compartment_getVolume(void * jarg1) {
  double jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  double result;
  
  arg1 = (Compartment *)jarg1; 
  result = (double)((Compartment const *)arg1)->getVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Compartment_getUnits(void * jarg1) {
  wchar_t* jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    std::string const &_result_ref = ((Compartment const *)arg1)->getUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Compartment_getOutside(void * jarg1) {
  wchar_t* jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    std::string const &_result_ref = ((Compartment const *)arg1)->getOutside();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_getConstant(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->getConstant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_isSetCompartmentType(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->isSetCompartmentType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_isSetSize(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->isSetSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_isSetVolume(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->isSetVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_isSetUnits(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->isSetUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Compartment_isSetOutside(void * jarg1) {
  unsigned int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  bool result;
  
  arg1 = (Compartment *)jarg1; 
  result = (bool)((Compartment const *)arg1)->isSetOutside();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setCompartmentType(void * jarg1, wchar_t* jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setCompartmentType((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setSpatialDimensions(void * jarg1, long long jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setSpatialDimensions(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setSize(void * jarg1, double jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  double arg2 ;
  
  arg1 = (Compartment *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setSize(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setVolume(void * jarg1, double jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  double arg2 ;
  
  arg1 = (Compartment *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setVolume(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setUnits(void * jarg1, wchar_t* jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setOutside(void * jarg1, wchar_t* jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setOutside((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_setConstant(void * jarg1, unsigned int jarg2) {
  Compartment *arg1 = (Compartment *) 0 ;
  bool arg2 ;
  
  arg1 = (Compartment *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setConstant(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_unsetCompartmentType(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->unsetCompartmentType();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_unsetSize(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->unsetSize();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_unsetVolume(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->unsetVolume();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_unsetUnits(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->unsetUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Compartment_unsetOutside(void * jarg1) {
  Compartment *arg1 = (Compartment *) 0 ;
  
  arg1 = (Compartment *)jarg1; 
  (arg1)->unsetOutside();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Compartment_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Compartment_getTypeCode(void * jarg1) {
  int jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Compartment *)jarg1; 
  result = (SBMLTypeCode_t)((Compartment const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Compartment_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Compartment *)jarg1; 
  {
    std::string const &_result_ref = ((Compartment const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartments_clone(void * jarg1) {
  void * jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  ListOfCompartments *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  result = (ListOfCompartments *)((ListOfCompartments const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfCompartments_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfCompartments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfCompartments const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfCompartments_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfCompartments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfCompartments const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfCompartments_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfCompartments const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartments_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  unsigned int arg2 ;
  Compartment *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Compartment *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartments_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Compartment *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Compartment *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartments_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  unsigned int arg2 ;
  Compartment *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Compartment *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfCompartments_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Compartment *result = 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Compartment *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfCompartments() {
  void * jresult ;
  ListOfCompartments *result = 0 ;
  
  result = (ListOfCompartments *)new ListOfCompartments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfCompartments(void * jarg1) {
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  
  arg1 = (ListOfCompartments *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Species *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Species *)new Species((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Species *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Species *)new Species((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_2() {
  void * jresult ;
  Species *result = 0 ;
  
  result = (Species *)new Species();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Species *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Species *)new Species(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Species *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Species *)new Species(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Species(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Species__SWIG_5(void * jarg1) {
  void * jresult ;
  Species *arg1 = 0 ;
  Species *result = 0 ;
  
  arg1 = (Species *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Species const & type is null", 0);
    return 0;
  } 
  result = (Species *)new Species((Species const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Species_clone(void * jarg1) {
  void * jresult ;
  Species *arg1 = (Species *) 0 ;
  Species *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  result = (Species *)((Species const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_initDefaults(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getSpeciesType(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getSpeciesType();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getCompartment(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getCompartment();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Species_getInitialAmount(void * jarg1) {
  double jresult ;
  Species *arg1 = (Species *) 0 ;
  double result;
  
  arg1 = (Species *)jarg1; 
  result = (double)((Species const *)arg1)->getInitialAmount();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Species_getInitialConcentration(void * jarg1) {
  double jresult ;
  Species *arg1 = (Species *) 0 ;
  double result;
  
  arg1 = (Species *)jarg1; 
  result = (double)((Species const *)arg1)->getInitialConcentration();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getSubstanceUnits(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getSubstanceUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getSpatialSizeUnits(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getSpatialSizeUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getUnits(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_getHasOnlySubstanceUnits(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->getHasOnlySubstanceUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_getBoundaryCondition(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->getBoundaryCondition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Species_getCharge(void * jarg1) {
  int jresult ;
  Species *arg1 = (Species *) 0 ;
  int result;
  
  arg1 = (Species *)jarg1; 
  result = (int)((Species const *)arg1)->getCharge();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_getConstant(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->getConstant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetSpeciesType(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetSpeciesType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetCompartment(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetCompartment();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetInitialAmount(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetInitialAmount();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetInitialConcentration(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetInitialConcentration();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetSubstanceUnits(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetSubstanceUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetSpatialSizeUnits(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetSpatialSizeUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetUnits(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Species_isSetCharge(void * jarg1) {
  unsigned int jresult ;
  Species *arg1 = (Species *) 0 ;
  bool result;
  
  arg1 = (Species *)jarg1; 
  result = (bool)((Species const *)arg1)->isSetCharge();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setSpeciesType(void * jarg1, wchar_t* jarg2) {
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Species *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSpeciesType((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setCompartment(void * jarg1, wchar_t* jarg2) {
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Species *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setCompartment((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setInitialAmount(void * jarg1, double jarg2) {
  Species *arg1 = (Species *) 0 ;
  double arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setInitialAmount(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setInitialConcentration(void * jarg1, double jarg2) {
  Species *arg1 = (Species *) 0 ;
  double arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setInitialConcentration(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setSubstanceUnits(void * jarg1, wchar_t* jarg2) {
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Species *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSubstanceUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setSpatialSizeUnits(void * jarg1, wchar_t* jarg2) {
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Species *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSpatialSizeUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setUnits(void * jarg1, wchar_t* jarg2) {
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Species *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setHasOnlySubstanceUnits(void * jarg1, unsigned int jarg2) {
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setHasOnlySubstanceUnits(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setBoundaryCondition(void * jarg1, unsigned int jarg2) {
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setBoundaryCondition(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setCharge(void * jarg1, int jarg2) {
  Species *arg1 = (Species *) 0 ;
  int arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->setCharge(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_setConstant(void * jarg1, unsigned int jarg2) {
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  
  arg1 = (Species *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setConstant(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetSpeciesType(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetSpeciesType();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetInitialAmount(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetInitialAmount();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetInitialConcentration(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetInitialConcentration();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetSubstanceUnits(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetSubstanceUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetSpatialSizeUnits(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetSpatialSizeUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetUnits(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Species_unsetCharge(void * jarg1) {
  Species *arg1 = (Species *) 0 ;
  
  arg1 = (Species *)jarg1; 
  (arg1)->unsetCharge();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Species_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  Species *arg1 = (Species *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Species_getTypeCode(void * jarg1) {
  int jresult ;
  Species *arg1 = (Species *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Species *)jarg1; 
  result = (SBMLTypeCode_t)((Species const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Species_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Species *arg1 = (Species *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Species *)jarg1; 
  {
    std::string const &_result_ref = ((Species const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpecies_clone(void * jarg1) {
  void * jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  ListOfSpecies *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  result = (ListOfSpecies *)((ListOfSpecies const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpecies_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpecies *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpecies const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpecies_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpecies *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpecies const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfSpecies_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfSpecies const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpecies_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  unsigned int arg2 ;
  Species *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Species *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpecies_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Species *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Species *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpecies_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  unsigned int arg2 ;
  Species *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Species *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpecies_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Species *result = 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Species *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfSpecies() {
  void * jresult ;
  ListOfSpecies *result = 0 ;
  
  result = (ListOfSpecies *)new ListOfSpecies();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfSpecies(void * jarg1) {
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  
  arg1 = (ListOfSpecies *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Parameter *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Parameter *)new Parameter((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Parameter *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Parameter *)new Parameter((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_2() {
  void * jresult ;
  Parameter *result = 0 ;
  
  result = (Parameter *)new Parameter();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_3(wchar_t* jarg1, double jarg2, wchar_t* jarg3, unsigned int jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  double arg2 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  std::string arg_str1 ;
  std::string arg_str3 ;
  Parameter *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (double)jarg2; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  arg4 = jarg4 ? true : false; 
  result = (Parameter *)new Parameter((std::string const &)*arg1,arg2,(std::string const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_4(wchar_t* jarg1, double jarg2, wchar_t* jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  double arg2 ;
  std::string *arg3 = 0 ;
  std::string arg_str1 ;
  std::string arg_str3 ;
  Parameter *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (double)jarg2; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (Parameter *)new Parameter((std::string const &)*arg1,arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_5(wchar_t* jarg1, double jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  double arg2 ;
  std::string arg_str1 ;
  Parameter *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (double)jarg2; 
  result = (Parameter *)new Parameter((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_6(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Parameter *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Parameter *)new Parameter(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_7(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Parameter *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Parameter *)new Parameter(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Parameter(void * jarg1) {
  Parameter *arg1 = (Parameter *) 0 ;
  
  arg1 = (Parameter *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Parameter__SWIG_8(void * jarg1) {
  void * jresult ;
  Parameter *arg1 = 0 ;
  Parameter *result = 0 ;
  
  arg1 = (Parameter *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & type is null", 0);
    return 0;
  } 
  result = (Parameter *)new Parameter((Parameter const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Parameter_clone(void * jarg1) {
  void * jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  Parameter *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  result = (Parameter *)((Parameter const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_initDefaults(void * jarg1) {
  Parameter *arg1 = (Parameter *) 0 ;
  
  arg1 = (Parameter *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT double SWIGSTDCALL CSharp_Parameter_getValue(void * jarg1) {
  double jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  double result;
  
  arg1 = (Parameter *)jarg1; 
  result = (double)((Parameter const *)arg1)->getValue();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Parameter_getUnits(void * jarg1) {
  wchar_t* jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    std::string const &_result_ref = ((Parameter const *)arg1)->getUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Parameter_getConstant(void * jarg1) {
  unsigned int jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  bool result;
  
  arg1 = (Parameter *)jarg1; 
  result = (bool)((Parameter const *)arg1)->getConstant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Parameter_isSetValue(void * jarg1) {
  unsigned int jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  bool result;
  
  arg1 = (Parameter *)jarg1; 
  result = (bool)((Parameter const *)arg1)->isSetValue();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Parameter_isSetUnits(void * jarg1) {
  unsigned int jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  bool result;
  
  arg1 = (Parameter *)jarg1; 
  result = (bool)((Parameter const *)arg1)->isSetUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_setValue(void * jarg1, double jarg2) {
  Parameter *arg1 = (Parameter *) 0 ;
  double arg2 ;
  
  arg1 = (Parameter *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setValue(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_setUnits(void * jarg1, wchar_t* jarg2) {
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_setConstant(void * jarg1, unsigned int jarg2) {
  Parameter *arg1 = (Parameter *) 0 ;
  bool arg2 ;
  
  arg1 = (Parameter *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setConstant(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_unsetValue(void * jarg1) {
  Parameter *arg1 = (Parameter *) 0 ;
  
  arg1 = (Parameter *)jarg1; 
  (arg1)->unsetValue();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Parameter_unsetUnits(void * jarg1) {
  Parameter *arg1 = (Parameter *) 0 ;
  
  arg1 = (Parameter *)jarg1; 
  (arg1)->unsetUnits();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Parameter_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Parameter_getTypeCode(void * jarg1) {
  int jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Parameter *)jarg1; 
  result = (SBMLTypeCode_t)((Parameter const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Parameter_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Parameter *)jarg1; 
  {
    std::string const &_result_ref = ((Parameter const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfParameters_clone(void * jarg1) {
  void * jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  ListOfParameters *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  result = (ListOfParameters *)((ListOfParameters const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfParameters_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfParameters *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfParameters const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfParameters_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfParameters *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfParameters const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfParameters_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfParameters const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfParameters_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  unsigned int arg2 ;
  Parameter *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Parameter *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfParameters_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Parameter *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Parameter *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfParameters_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  unsigned int arg2 ;
  Parameter *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Parameter *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfParameters_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Parameter *result = 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Parameter *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfParameters() {
  void * jresult ;
  ListOfParameters *result = 0 ;
  
  result = (ListOfParameters *)new ListOfParameters();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfParameters(void * jarg1) {
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  
  arg1 = (ListOfParameters *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_InitialAssignment__SWIG_0(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  InitialAssignment *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (InitialAssignment *)new InitialAssignment((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_InitialAssignment__SWIG_1() {
  void * jresult ;
  InitialAssignment *result = 0 ;
  
  result = (InitialAssignment *)new InitialAssignment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_InitialAssignment__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  InitialAssignment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (InitialAssignment *)new InitialAssignment(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_InitialAssignment__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  InitialAssignment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (InitialAssignment *)new InitialAssignment(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_InitialAssignment(void * jarg1) {
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_InitialAssignment__SWIG_4(void * jarg1) {
  void * jresult ;
  InitialAssignment *arg1 = 0 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InitialAssignment const & type is null", 0);
    return 0;
  } 
  result = (InitialAssignment *)new InitialAssignment((InitialAssignment const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_InitialAssignment_clone(void * jarg1) {
  void * jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (InitialAssignment *)((InitialAssignment const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_InitialAssignment_getSymbol(void * jarg1) {
  wchar_t* jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  {
    std::string const &_result_ref = ((InitialAssignment const *)arg1)->getSymbol();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_InitialAssignment_getMath(void * jarg1) {
  void * jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (ASTNode *)((InitialAssignment const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_InitialAssignment_isSetSymbol(void * jarg1) {
  unsigned int jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  bool result;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (bool)((InitialAssignment const *)arg1)->isSetSymbol();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_InitialAssignment_isSetMath(void * jarg1) {
  unsigned int jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  bool result;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (bool)((InitialAssignment const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_InitialAssignment_setSymbol(void * jarg1, wchar_t* jarg2) {
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSymbol((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_InitialAssignment_setMath(void * jarg1, void * jarg2) {
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_InitialAssignment_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_InitialAssignment_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  bool result;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_InitialAssignment_getTypeCode(void * jarg1) {
  int jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (InitialAssignment *)jarg1; 
  result = (SBMLTypeCode_t)((InitialAssignment const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_InitialAssignment_getElementName(void * jarg1) {
  wchar_t* jresult ;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (InitialAssignment *)jarg1; 
  {
    std::string const &_result_ref = ((InitialAssignment const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfInitialAssignments_clone(void * jarg1) {
  void * jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  result = (ListOfInitialAssignments *)((ListOfInitialAssignments const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfInitialAssignments_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfInitialAssignments const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfInitialAssignments_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfInitialAssignments const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfInitialAssignments_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfInitialAssignments const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfInitialAssignments_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  unsigned int arg2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (InitialAssignment *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfInitialAssignments_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (InitialAssignment *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfInitialAssignments_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  unsigned int arg2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (InitialAssignment *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfInitialAssignments_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  InitialAssignment *result = 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (InitialAssignment *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfInitialAssignments() {
  void * jresult ;
  ListOfInitialAssignments *result = 0 ;
  
  result = (ListOfInitialAssignments *)new ListOfInitialAssignments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfInitialAssignments(void * jarg1) {
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  
  arg1 = (ListOfInitialAssignments *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Rule(void * jarg1) {
  Rule *arg1 = (Rule *) 0 ;
  
  arg1 = (Rule *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Rule(void * jarg1) {
  void * jresult ;
  Rule *arg1 = 0 ;
  Rule *result = 0 ;
  
  arg1 = (Rule *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Rule const & type is null", 0);
    return 0;
  } 
  result = (Rule *)new Rule((Rule const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Rule_clone(void * jarg1) {
  void * jresult ;
  Rule *arg1 = (Rule *) 0 ;
  Rule *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  result = (Rule *)((Rule const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Rule_getFormula(void * jarg1) {
  wchar_t* jresult ;
  Rule *arg1 = (Rule *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  {
    std::string const &_result_ref = ((Rule const *)arg1)->getFormula();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Rule_getMath(void * jarg1) {
  void * jresult ;
  Rule *arg1 = (Rule *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  result = (ASTNode *)((Rule const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Rule_getVariable(void * jarg1) {
  wchar_t* jresult ;
  Rule *arg1 = (Rule *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  {
    std::string const &_result_ref = ((Rule const *)arg1)->getVariable();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Rule_getUnits(void * jarg1) {
  wchar_t* jresult ;
  Rule *arg1 = (Rule *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  {
    std::string const &_result_ref = ((Rule const *)arg1)->getUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isSetFormula(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isSetFormula();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isSetMath(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isSetVariable(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isSetVariable();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isSetUnits(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isSetUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_setFormula(void * jarg1, wchar_t* jarg2) {
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Rule *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setFormula((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_setMath(void * jarg1, void * jarg2) {
  Rule *arg1 = (Rule *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (Rule *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_setVariable(void * jarg1, wchar_t* jarg2) {
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Rule *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setVariable((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_setUnits(void * jarg1, wchar_t* jarg2) {
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Rule *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_unsetUnits(void * jarg1) {
  Rule *arg1 = (Rule *) 0 ;
  
  arg1 = (Rule *)jarg1; 
  (arg1)->unsetUnits();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Rule_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  Rule *arg1 = (Rule *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Rule_getType(void * jarg1) {
  int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  RuleType_t result;
  
  arg1 = (Rule *)jarg1; 
  result = (RuleType_t)((Rule const *)arg1)->getType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isAlgebraic(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isAlgebraic();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isAssignment(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isAssignment();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isCompartmentVolume(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isCompartmentVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isParameter(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isParameter();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isRate(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isRate();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isScalar(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isScalar();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Rule_isSpeciesConcentration(void * jarg1) {
  unsigned int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  bool result;
  
  arg1 = (Rule *)jarg1; 
  result = (bool)((Rule const *)arg1)->isSpeciesConcentration();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Rule_getTypeCode(void * jarg1) {
  int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Rule *)jarg1; 
  result = (SBMLTypeCode_t)((Rule const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Rule_getL1TypeCode(void * jarg1) {
  int jresult ;
  Rule *arg1 = (Rule *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Rule *)jarg1; 
  result = (SBMLTypeCode_t)((Rule const *)arg1)->getL1TypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Rule_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Rule *arg1 = (Rule *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Rule *)jarg1; 
  {
    std::string const &_result_ref = ((Rule const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Rule_setL1TypeCode(void * jarg1, int jarg2) {
  Rule *arg1 = (Rule *) 0 ;
  SBMLTypeCode_t arg2 ;
  
  arg1 = (Rule *)jarg1; 
  arg2 = (SBMLTypeCode_t)jarg2; 
  (arg1)->setL1TypeCode(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AlgebraicRule__SWIG_0(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  AlgebraicRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (AlgebraicRule *)new AlgebraicRule((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AlgebraicRule__SWIG_1() {
  void * jresult ;
  AlgebraicRule *result = 0 ;
  
  result = (AlgebraicRule *)new AlgebraicRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AlgebraicRule__SWIG_2(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  AlgebraicRule *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (AlgebraicRule *)new AlgebraicRule((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AlgebraicRule__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  AlgebraicRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (AlgebraicRule *)new AlgebraicRule(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AlgebraicRule__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  AlgebraicRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (AlgebraicRule *)new AlgebraicRule(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_AlgebraicRule(void * jarg1) {
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  
  arg1 = (AlgebraicRule *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_AlgebraicRule_clone(void * jarg1) {
  void * jresult ;
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  AlgebraicRule *result = 0 ;
  
  arg1 = (AlgebraicRule *)jarg1; 
  result = (AlgebraicRule *)((AlgebraicRule const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_AlgebraicRule_setInternalIdOnly(void * jarg1) {
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  
  arg1 = (AlgebraicRule *)jarg1; 
  (arg1)->setInternalIdOnly();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_AlgebraicRule_getInternalIdOnly(void * jarg1) {
  unsigned int jresult ;
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  bool result;
  
  arg1 = (AlgebraicRule *)jarg1; 
  result = (bool)((AlgebraicRule const *)arg1)->getInternalIdOnly();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  AssignmentRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (AssignmentRule *)new AssignmentRule((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  AssignmentRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (AssignmentRule *)new AssignmentRule((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_2() {
  void * jresult ;
  AssignmentRule *result = 0 ;
  
  result = (AssignmentRule *)new AssignmentRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_3(wchar_t* jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  std::string arg_str1 ;
  AssignmentRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (ASTNode *)jarg2; 
  result = (AssignmentRule *)new AssignmentRule((std::string const &)*arg1,(ASTNode const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_4(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  AssignmentRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (AssignmentRule *)new AssignmentRule(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AssignmentRule__SWIG_5(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  AssignmentRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (AssignmentRule *)new AssignmentRule(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_AssignmentRule(void * jarg1) {
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  
  arg1 = (AssignmentRule *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_AssignmentRule_clone(void * jarg1) {
  void * jresult ;
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  AssignmentRule *result = 0 ;
  
  arg1 = (AssignmentRule *)jarg1; 
  result = (AssignmentRule *)((AssignmentRule const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  RateRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (RateRule *)new RateRule((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  RateRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (RateRule *)new RateRule((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_2() {
  void * jresult ;
  RateRule *result = 0 ;
  
  result = (RateRule *)new RateRule();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_3(wchar_t* jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  std::string arg_str1 ;
  RateRule *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (ASTNode *)jarg2; 
  result = (RateRule *)new RateRule((std::string const &)*arg1,(ASTNode const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_4(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  RateRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (RateRule *)new RateRule(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RateRule__SWIG_5(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  RateRule *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (RateRule *)new RateRule(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_RateRule(void * jarg1) {
  RateRule *arg1 = (RateRule *) 0 ;
  
  arg1 = (RateRule *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RateRule_clone(void * jarg1) {
  void * jresult ;
  RateRule *arg1 = (RateRule *) 0 ;
  RateRule *result = 0 ;
  
  arg1 = (RateRule *)jarg1; 
  result = (RateRule *)((RateRule const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfRules_clone(void * jarg1) {
  void * jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  ListOfRules *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  result = (ListOfRules *)((ListOfRules const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfRules_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfRules *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfRules const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfRules_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfRules *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfRules const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfRules_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfRules const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfRules_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  unsigned int arg2 ;
  Rule *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Rule *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfRules_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Rule *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Rule *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfRules_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  unsigned int arg2 ;
  Rule *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Rule *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfRules_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Rule *result = 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Rule *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfRules() {
  void * jresult ;
  ListOfRules *result = 0 ;
  
  result = (ListOfRules *)new ListOfRules();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfRules(void * jarg1) {
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  
  arg1 = (ListOfRules *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Constraint__SWIG_0(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  Constraint *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (Constraint *)new Constraint((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Constraint__SWIG_1() {
  void * jresult ;
  Constraint *result = 0 ;
  
  result = (Constraint *)new Constraint();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Constraint__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Constraint *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Constraint *)new Constraint(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Constraint__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Constraint *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Constraint *)new Constraint(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Constraint(void * jarg1) {
  Constraint *arg1 = (Constraint *) 0 ;
  
  arg1 = (Constraint *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Constraint__SWIG_4(void * jarg1) {
  void * jresult ;
  Constraint *arg1 = 0 ;
  Constraint *result = 0 ;
  
  arg1 = (Constraint *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & type is null", 0);
    return 0;
  } 
  result = (Constraint *)new Constraint((Constraint const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Constraint_clone(void * jarg1) {
  void * jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  Constraint *result = 0 ;
  
  arg1 = (Constraint *)jarg1; 
  result = (Constraint *)((Constraint const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Constraint_getMessage(void * jarg1) {
  void * jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (Constraint *)jarg1; 
  result = (XMLNode *)((Constraint const *)arg1)->getMessage();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Constraint_getMessageString(void * jarg1) {
  wchar_t* jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string result;
  
  arg1 = (Constraint *)jarg1; 
  result = ((Constraint const *)arg1)->getMessageString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Constraint_getMath(void * jarg1) {
  void * jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (Constraint *)jarg1; 
  result = (ASTNode *)((Constraint const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Constraint_isSetMessage(void * jarg1) {
  unsigned int jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  bool result;
  
  arg1 = (Constraint *)jarg1; 
  result = (bool)((Constraint const *)arg1)->isSetMessage();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Constraint_isSetMath(void * jarg1) {
  unsigned int jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  bool result;
  
  arg1 = (Constraint *)jarg1; 
  result = (bool)((Constraint const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Constraint_setMessage(void * jarg1, void * jarg2) {
  Constraint *arg1 = (Constraint *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (Constraint *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->setMessage((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Constraint_setMath(void * jarg1, void * jarg2) {
  Constraint *arg1 = (Constraint *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (Constraint *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Constraint_unsetMessage(void * jarg1) {
  Constraint *arg1 = (Constraint *) 0 ;
  
  arg1 = (Constraint *)jarg1; 
  (arg1)->unsetMessage();
}


SWIGEXPORT int SWIGSTDCALL CSharp_Constraint_getTypeCode(void * jarg1) {
  int jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Constraint *)jarg1; 
  result = (SBMLTypeCode_t)((Constraint const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Constraint_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Constraint *)jarg1; 
  {
    std::string const &_result_ref = ((Constraint const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfConstraints_clone(void * jarg1) {
  void * jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  ListOfConstraints *result = 0 ;
  
  arg1 = (ListOfConstraints *)jarg1; 
  result = (ListOfConstraints *)((ListOfConstraints const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfConstraints_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfConstraints *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfConstraints const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfConstraints_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfConstraints *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfConstraints const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfConstraints_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfConstraints *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfConstraints const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfConstraints_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  unsigned int arg2 ;
  Constraint *result = 0 ;
  
  arg1 = (ListOfConstraints *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Constraint *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfConstraints_remove(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  unsigned int arg2 ;
  Constraint *result = 0 ;
  
  arg1 = (ListOfConstraints *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Constraint *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfConstraints() {
  void * jresult ;
  ListOfConstraints *result = 0 ;
  
  result = (ListOfConstraints *)new ListOfConstraints();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfConstraints(void * jarg1) {
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  
  arg1 = (ListOfConstraints *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_0(wchar_t* jarg1, wchar_t* jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  KineticLaw *arg3 = (KineticLaw *) 0 ;
  bool arg4 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = (KineticLaw *)jarg3; 
  arg4 = jarg4 ? true : false; 
  result = (Reaction *)new Reaction((std::string const &)*arg1,(std::string const &)*arg2,(KineticLaw const *)arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_1(wchar_t* jarg1, wchar_t* jarg2, void * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  KineticLaw *arg3 = (KineticLaw *) 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = (KineticLaw *)jarg3; 
  result = (Reaction *)new Reaction((std::string const &)*arg1,(std::string const &)*arg2,(KineticLaw const *)arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_2(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Reaction *)new Reaction((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_3(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Reaction *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Reaction *)new Reaction((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_4() {
  void * jresult ;
  Reaction *result = 0 ;
  
  result = (Reaction *)new Reaction();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_5(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Reaction *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Reaction *)new Reaction(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_6(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Reaction *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Reaction *)new Reaction(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Reaction(void * jarg1) {
  Reaction *arg1 = (Reaction *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Reaction__SWIG_7(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = 0 ;
  Reaction *result = 0 ;
  
  arg1 = (Reaction *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Reaction const & type is null", 0);
    return 0;
  } 
  result = (Reaction *)new Reaction((Reaction const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_clone(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  Reaction *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (Reaction *)((Reaction const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_initDefaults(void * jarg1) {
  Reaction *arg1 = (Reaction *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getKineticLaw__SWIG_0(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (KineticLaw *)((Reaction const *)arg1)->getKineticLaw();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_getReversible(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  bool result;
  
  arg1 = (Reaction *)jarg1; 
  result = (bool)((Reaction const *)arg1)->getReversible();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_getFast(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  bool result;
  
  arg1 = (Reaction *)jarg1; 
  result = (bool)((Reaction const *)arg1)->getFast();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_isSetKineticLaw(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  bool result;
  
  arg1 = (Reaction *)jarg1; 
  result = (bool)((Reaction const *)arg1)->isSetKineticLaw();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_isSetFast(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  bool result;
  
  arg1 = (Reaction *)jarg1; 
  result = (bool)((Reaction const *)arg1)->isSetFast();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_setKineticLaw(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  KineticLaw *arg2 = (KineticLaw *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (KineticLaw *)jarg2; 
  (arg1)->setKineticLaw((KineticLaw const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_setReversible(void * jarg1, unsigned int jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  bool arg2 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setReversible(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_setFast(void * jarg1, unsigned int jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  bool arg2 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setFast(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_unsetKineticLaw(void * jarg1) {
  Reaction *arg1 = (Reaction *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  (arg1)->unsetKineticLaw();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_unsetFast(void * jarg1) {
  Reaction *arg1 = (Reaction *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  (arg1)->unsetFast();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_addReactant(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *arg2 = (SpeciesReference *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (SpeciesReference *)jarg2; 
  (arg1)->addReactant((SpeciesReference const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_addProduct(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *arg2 = (SpeciesReference *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (SpeciesReference *)jarg2; 
  (arg1)->addProduct((SpeciesReference const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_addModifier(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  ModifierSpeciesReference *arg2 = (ModifierSpeciesReference *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (ModifierSpeciesReference *)jarg2; 
  (arg1)->addModifier((ModifierSpeciesReference const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_createReactant(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (SpeciesReference *)(arg1)->createReactant();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_createProduct(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (SpeciesReference *)(arg1)->createProduct();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_createModifier(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (ModifierSpeciesReference *)(arg1)->createModifier();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_createKineticLaw(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (KineticLaw *)(arg1)->createKineticLaw();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getListOfReactants__SWIG_0(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfReactants();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getListOfProducts__SWIG_0(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfProducts();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getListOfModifiers__SWIG_0(void * jarg1) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfModifiers();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getReactant__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getReactant(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getReactant__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getReactant((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getProduct__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getProduct(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getProduct__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getProduct((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getModifier__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  ModifierSpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (ModifierSpeciesReference *)((Reaction const *)arg1)->getModifier(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Reaction_getModifier__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  ModifierSpeciesReference *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (ModifierSpeciesReference *)((Reaction const *)arg1)->getModifier((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_getNumReactants(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int result;
  
  arg1 = (Reaction *)jarg1; 
  result = (unsigned int)((Reaction const *)arg1)->getNumReactants();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_getNumProducts(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int result;
  
  arg1 = (Reaction *)jarg1; 
  result = (unsigned int)((Reaction const *)arg1)->getNumProducts();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Reaction_getNumModifiers(void * jarg1) {
  unsigned int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int result;
  
  arg1 = (Reaction *)jarg1; 
  result = (unsigned int)((Reaction const *)arg1)->getNumModifiers();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_setSBMLDocument(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Reaction_setParentSBMLObject(void * jarg1, void * jarg2) {
  Reaction *arg1 = (Reaction *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (Reaction *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Reaction_getTypeCode(void * jarg1) {
  int jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Reaction *)jarg1; 
  result = (SBMLTypeCode_t)((Reaction const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Reaction_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Reaction *)jarg1; 
  {
    std::string const &_result_ref = ((Reaction const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfReactions_clone(void * jarg1) {
  void * jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  ListOfReactions *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  result = (ListOfReactions *)((ListOfReactions const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfReactions_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfReactions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfReactions const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfReactions_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfReactions *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfReactions const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfReactions_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfReactions const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfReactions_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  unsigned int arg2 ;
  Reaction *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Reaction *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfReactions_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Reaction *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfReactions_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  unsigned int arg2 ;
  Reaction *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Reaction *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfReactions_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Reaction *result = 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Reaction *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfReactions() {
  void * jresult ;
  ListOfReactions *result = 0 ;
  
  result = (ListOfReactions *)new ListOfReactions();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfReactions(void * jarg1) {
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  
  arg1 = (ListOfReactions *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_0(wchar_t* jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  KineticLaw *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (KineticLaw *)new KineticLaw((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_1(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  KineticLaw *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (KineticLaw *)new KineticLaw((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_2(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  KineticLaw *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (KineticLaw *)new KineticLaw((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_3() {
  void * jresult ;
  KineticLaw *result = 0 ;
  
  result = (KineticLaw *)new KineticLaw();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_4(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  KineticLaw *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (KineticLaw *)new KineticLaw((ASTNode const *)arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_5(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  KineticLaw *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (KineticLaw *)new KineticLaw((ASTNode const *)arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_6(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (KineticLaw *)new KineticLaw((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_7(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  KineticLaw *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (KineticLaw *)new KineticLaw(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_8(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  KineticLaw *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (KineticLaw *)new KineticLaw(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_KineticLaw(void * jarg1) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_KineticLaw__SWIG_9(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KineticLaw const & type is null", 0);
    return 0;
  } 
  result = (KineticLaw *)new KineticLaw((KineticLaw const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_clone(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  KineticLaw *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (KineticLaw *)((KineticLaw const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_KineticLaw_getFormula(void * jarg1) {
  wchar_t* jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    std::string const &_result_ref = ((KineticLaw const *)arg1)->getFormula();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_getMath(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (ASTNode *)((KineticLaw const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_KineticLaw_getTimeUnits(void * jarg1) {
  wchar_t* jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    std::string const &_result_ref = ((KineticLaw const *)arg1)->getTimeUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_KineticLaw_getSubstanceUnits(void * jarg1) {
  wchar_t* jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    std::string const &_result_ref = ((KineticLaw const *)arg1)->getSubstanceUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_isSetFormula(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  bool result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (bool)((KineticLaw const *)arg1)->isSetFormula();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_isSetMath(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  bool result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (bool)((KineticLaw const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_isSetTimeUnits(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  bool result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (bool)((KineticLaw const *)arg1)->isSetTimeUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_isSetSubstanceUnits(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  bool result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (bool)((KineticLaw const *)arg1)->isSetSubstanceUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setFormula(void * jarg1, wchar_t* jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setFormula((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setMath(void * jarg1, void * jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setTimeUnits(void * jarg1, wchar_t* jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setTimeUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setSubstanceUnits(void * jarg1, wchar_t* jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSubstanceUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_unsetTimeUnits(void * jarg1) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  (arg1)->unsetTimeUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_unsetSubstanceUnits(void * jarg1) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  (arg1)->unsetSubstanceUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_addParameter(void * jarg1, void * jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  Parameter *arg2 = (Parameter *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  arg2 = (Parameter *)jarg2; 
  (arg1)->addParameter((Parameter const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_createParameter(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  Parameter *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (Parameter *)(arg1)->createParameter();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_getListOfParameters__SWIG_0(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  ListOfParameters *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (ListOfParameters *)((KineticLaw const *)arg1)->getListOfParameters();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_getParameter__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  Parameter *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Parameter *)((KineticLaw const *)arg1)->getParameter(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_getParameter__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Parameter *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Parameter *)((KineticLaw const *)arg1)->getParameter((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_getNumParameters(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (unsigned int)((KineticLaw const *)arg1)->getNumParameters();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_KineticLaw_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KineticLaw_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  bool result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setSBMLDocument(void * jarg1, void * jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_KineticLaw_setParentSBMLObject(void * jarg1, void * jarg2) {
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_KineticLaw_getTypeCode(void * jarg1) {
  int jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (KineticLaw *)jarg1; 
  result = (SBMLTypeCode_t)((KineticLaw const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_KineticLaw_getElementName(void * jarg1) {
  wchar_t* jresult ;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (KineticLaw *)jarg1; 
  {
    std::string const &_result_ref = ((KineticLaw const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SimpleSpeciesReference(void * jarg1) {
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  
  arg1 = (SimpleSpeciesReference *)jarg1; 
  delete arg1;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SimpleSpeciesReference_getSpecies(void * jarg1) {
  wchar_t* jresult ;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SimpleSpeciesReference *)jarg1; 
  {
    std::string const &_result_ref = ((SimpleSpeciesReference const *)arg1)->getSpecies();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SimpleSpeciesReference_isSetSpecies(void * jarg1) {
  unsigned int jresult ;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  bool result;
  
  arg1 = (SimpleSpeciesReference *)jarg1; 
  result = (bool)((SimpleSpeciesReference const *)arg1)->isSetSpecies();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SimpleSpeciesReference_setSpecies(void * jarg1, wchar_t* jarg2) {
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SimpleSpeciesReference *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setSpecies((std::string const &)*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SimpleSpeciesReference_isModifier(void * jarg1) {
  unsigned int jresult ;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  bool result;
  
  arg1 = (SimpleSpeciesReference *)jarg1; 
  result = (bool)((SimpleSpeciesReference const *)arg1)->isModifier();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_0(wchar_t* jarg1, double jarg2, int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  double arg2 ;
  int arg3 ;
  std::string arg_str1 ;
  SpeciesReference *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (double)jarg2; 
  arg3 = (int)jarg3; 
  result = (SpeciesReference *)new SpeciesReference((std::string const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_1(wchar_t* jarg1, double jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  double arg2 ;
  std::string arg_str1 ;
  SpeciesReference *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (double)jarg2; 
  result = (SpeciesReference *)new SpeciesReference((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_2(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  SpeciesReference *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (SpeciesReference *)new SpeciesReference((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_3() {
  void * jresult ;
  SpeciesReference *result = 0 ;
  
  result = (SpeciesReference *)new SpeciesReference();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_4(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  SpeciesReference *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (SpeciesReference *)new SpeciesReference(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_5(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  SpeciesReference *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SpeciesReference *)new SpeciesReference(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SpeciesReference(void * jarg1) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpeciesReference__SWIG_6(void * jarg1) {
  void * jresult ;
  SpeciesReference *arg1 = 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (SpeciesReference *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SpeciesReference const & type is null", 0);
    return 0;
  } 
  result = (SpeciesReference *)new SpeciesReference((SpeciesReference const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SpeciesReference_clone(void * jarg1) {
  void * jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  SpeciesReference *result = 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (SpeciesReference *)((SpeciesReference const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_initDefaults(void * jarg1) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  (arg1)->initDefaults();
}


SWIGEXPORT double SWIGSTDCALL CSharp_SpeciesReference_getStoichiometry(void * jarg1) {
  double jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  double result;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (double)((SpeciesReference const *)arg1)->getStoichiometry();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SpeciesReference_getStoichiometryMath__SWIG_0(void * jarg1) {
  void * jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  StoichiometryMath *result = 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (StoichiometryMath *)((SpeciesReference const *)arg1)->getStoichiometryMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SpeciesReference_getDenominator(void * jarg1) {
  int jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  int result;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (int)((SpeciesReference const *)arg1)->getDenominator();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SpeciesReference_isSetStoichiometryMath(void * jarg1) {
  unsigned int jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  bool result;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (bool)((SpeciesReference const *)arg1)->isSetStoichiometryMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_setStoichiometry(void * jarg1, double jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  double arg2 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setStoichiometry(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_setStoichiometryMath(void * jarg1, void * jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  StoichiometryMath *arg2 = (StoichiometryMath *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  arg2 = (StoichiometryMath *)jarg2; 
  (arg1)->setStoichiometryMath((StoichiometryMath const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_setDenominator(void * jarg1, int jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  int arg2 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->setDenominator(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_unsetStoichiometryMath(void * jarg1) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  (arg1)->unsetStoichiometryMath();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_setAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->setAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_setAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setAnnotation((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_appendAnnotation__SWIG_0(void * jarg1, void * jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->appendAnnotation((XMLNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_appendAnnotation__SWIG_1(void * jarg1, wchar_t* jarg2) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->appendAnnotation((std::string const &)*arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_SpeciesReference_getTypeCode(void * jarg1) {
  int jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (SpeciesReference *)jarg1; 
  result = (SBMLTypeCode_t)((SpeciesReference const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SpeciesReference_getElementName(void * jarg1) {
  wchar_t* jresult ;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  {
    std::string const &_result_ref = ((SpeciesReference const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SpeciesReference_sortMath(void * jarg1) {
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  
  arg1 = (SpeciesReference *)jarg1; 
  (arg1)->sortMath();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModifierSpeciesReference__SWIG_0(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  ModifierSpeciesReference *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (ModifierSpeciesReference *)new ModifierSpeciesReference((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModifierSpeciesReference__SWIG_1() {
  void * jresult ;
  ModifierSpeciesReference *result = 0 ;
  
  result = (ModifierSpeciesReference *)new ModifierSpeciesReference();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModifierSpeciesReference__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (ModifierSpeciesReference *)new ModifierSpeciesReference(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModifierSpeciesReference__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  ModifierSpeciesReference *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (ModifierSpeciesReference *)new ModifierSpeciesReference(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ModifierSpeciesReference(void * jarg1) {
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  
  arg1 = (ModifierSpeciesReference *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModifierSpeciesReference_clone(void * jarg1) {
  void * jresult ;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  arg1 = (ModifierSpeciesReference *)jarg1; 
  result = (ModifierSpeciesReference *)((ModifierSpeciesReference const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ModifierSpeciesReference_getTypeCode(void * jarg1) {
  int jresult ;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ModifierSpeciesReference *)jarg1; 
  result = (SBMLTypeCode_t)((ModifierSpeciesReference const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModifierSpeciesReference_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ModifierSpeciesReference *)jarg1; 
  {
    std::string const &_result_ref = ((ModifierSpeciesReference const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfSpeciesReferences() {
  void * jresult ;
  ListOfSpeciesReferences *result = 0 ;
  
  result = (ListOfSpeciesReferences *)new ListOfSpeciesReferences();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesReferences_clone(void * jarg1) {
  void * jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  result = (ListOfSpeciesReferences *)((ListOfSpeciesReferences const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpeciesReferences_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpeciesReferences const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfSpeciesReferences_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfSpeciesReferences const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfSpeciesReferences_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfSpeciesReferences const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesReferences_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  unsigned int arg2 ;
  SimpleSpeciesReference *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SimpleSpeciesReference *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesReferences_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SimpleSpeciesReference *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SimpleSpeciesReference *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesReferences_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  unsigned int arg2 ;
  SimpleSpeciesReference *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SimpleSpeciesReference *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfSpeciesReferences_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  SimpleSpeciesReference *result = 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (SimpleSpeciesReference *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfSpeciesReferences(void * jarg1) {
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  
  arg1 = (ListOfSpeciesReferences *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_0(wchar_t* jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  Event *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Event *)new Event((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  Event *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (Event *)new Event((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_2() {
  void * jresult ;
  Event *result = 0 ;
  
  result = (Event *)new Event();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Event *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Event *)new Event(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Event *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Event *)new Event(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Event(void * jarg1) {
  Event *arg1 = (Event *) 0 ;
  
  arg1 = (Event *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Event__SWIG_5(void * jarg1) {
  void * jresult ;
  Event *arg1 = 0 ;
  Event *result = 0 ;
  
  arg1 = (Event *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Event const & type is null", 0);
    return 0;
  } 
  result = (Event *)new Event((Event const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_clone(void * jarg1) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  Event *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  result = (Event *)((Event const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_getTrigger__SWIG_0(void * jarg1) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  Trigger *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  result = (Trigger *)((Event const *)arg1)->getTrigger();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_getDelay__SWIG_0(void * jarg1) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  Delay *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  result = (Delay *)((Event const *)arg1)->getDelay();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Event_getTimeUnits(void * jarg1) {
  wchar_t* jresult ;
  Event *arg1 = (Event *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  {
    std::string const &_result_ref = ((Event const *)arg1)->getTimeUnits();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Event_getUseValuesFromTriggerTime(void * jarg1) {
  unsigned int jresult ;
  Event *arg1 = (Event *) 0 ;
  bool result;
  
  arg1 = (Event *)jarg1; 
  result = (bool)((Event const *)arg1)->getUseValuesFromTriggerTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Event_isSetTrigger(void * jarg1) {
  unsigned int jresult ;
  Event *arg1 = (Event *) 0 ;
  bool result;
  
  arg1 = (Event *)jarg1; 
  result = (bool)((Event const *)arg1)->isSetTrigger();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Event_isSetDelay(void * jarg1) {
  unsigned int jresult ;
  Event *arg1 = (Event *) 0 ;
  bool result;
  
  arg1 = (Event *)jarg1; 
  result = (bool)((Event const *)arg1)->isSetDelay();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Event_isSetTimeUnits(void * jarg1) {
  unsigned int jresult ;
  Event *arg1 = (Event *) 0 ;
  bool result;
  
  arg1 = (Event *)jarg1; 
  result = (bool)((Event const *)arg1)->isSetTimeUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setTrigger(void * jarg1, void * jarg2) {
  Event *arg1 = (Event *) 0 ;
  Trigger *arg2 = (Trigger *) 0 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = (Trigger *)jarg2; 
  (arg1)->setTrigger((Trigger const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setDelay(void * jarg1, void * jarg2) {
  Event *arg1 = (Event *) 0 ;
  Delay *arg2 = (Delay *) 0 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = (Delay *)jarg2; 
  (arg1)->setDelay((Delay const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setTimeUnits(void * jarg1, wchar_t* jarg2) {
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (Event *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setTimeUnits((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setUseValuesFromTriggerTime(void * jarg1, unsigned int jarg2) {
  Event *arg1 = (Event *) 0 ;
  bool arg2 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setUseValuesFromTriggerTime(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_unsetDelay(void * jarg1) {
  Event *arg1 = (Event *) 0 ;
  
  arg1 = (Event *)jarg1; 
  (arg1)->unsetDelay();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_unsetTimeUnits(void * jarg1) {
  Event *arg1 = (Event *) 0 ;
  
  arg1 = (Event *)jarg1; 
  (arg1)->unsetTimeUnits();
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_addEventAssignment(void * jarg1, void * jarg2) {
  Event *arg1 = (Event *) 0 ;
  EventAssignment *arg2 = (EventAssignment *) 0 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = (EventAssignment *)jarg2; 
  (arg1)->addEventAssignment((EventAssignment const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_createEventAssignment(void * jarg1) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  EventAssignment *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  result = (EventAssignment *)(arg1)->createEventAssignment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_getListOfEventAssignments__SWIG_0(void * jarg1) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  ListOfEventAssignments *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  result = (ListOfEventAssignments *)((Event const *)arg1)->getListOfEventAssignments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_getEventAssignment__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  unsigned int arg2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (EventAssignment *)((Event const *)arg1)->getEventAssignment(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Event_getEventAssignment__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (EventAssignment *)((Event const *)arg1)->getEventAssignment((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Event_getNumEventAssignments(void * jarg1) {
  unsigned int jresult ;
  Event *arg1 = (Event *) 0 ;
  unsigned int result;
  
  arg1 = (Event *)jarg1; 
  result = (unsigned int)((Event const *)arg1)->getNumEventAssignments();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setSBMLDocument(void * jarg1, void * jarg2) {
  Event *arg1 = (Event *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setParentSBMLObject(void * jarg1, void * jarg2) {
  Event *arg1 = (Event *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (Event *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Event_getTypeCode(void * jarg1) {
  int jresult ;
  Event *arg1 = (Event *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Event *)jarg1; 
  result = (SBMLTypeCode_t)((Event const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Event_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Event *arg1 = (Event *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Event *)jarg1; 
  {
    std::string const &_result_ref = ((Event const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Event_setInternalIdOnly(void * jarg1) {
  Event *arg1 = (Event *) 0 ;
  
  arg1 = (Event *)jarg1; 
  (arg1)->setInternalIdOnly();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEvents_clone(void * jarg1) {
  void * jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  ListOfEvents *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  result = (ListOfEvents *)((ListOfEvents const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfEvents_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfEvents *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfEvents const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfEvents_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfEvents *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfEvents const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfEvents_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfEvents const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEvents_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  unsigned int arg2 ;
  Event *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Event *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEvents_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Event *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Event *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEvents_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  unsigned int arg2 ;
  Event *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Event *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEvents_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  Event *result = 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (Event *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfEvents() {
  void * jresult ;
  ListOfEvents *result = 0 ;
  
  result = (ListOfEvents *)new ListOfEvents();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfEvents(void * jarg1) {
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  
  arg1 = (ListOfEvents *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_0(wchar_t* jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  std::string arg_str1 ;
  EventAssignment *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (ASTNode *)jarg2; 
  result = (EventAssignment *)new EventAssignment((std::string const &)*arg1,(ASTNode const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  EventAssignment *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (EventAssignment *)new EventAssignment((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_2() {
  void * jresult ;
  EventAssignment *result = 0 ;
  
  result = (EventAssignment *)new EventAssignment();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_3(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  EventAssignment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (EventAssignment *)new EventAssignment(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_4(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  EventAssignment *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (EventAssignment *)new EventAssignment(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_EventAssignment(void * jarg1) {
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventAssignment__SWIG_5(void * jarg1) {
  void * jresult ;
  EventAssignment *arg1 = 0 ;
  EventAssignment *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EventAssignment const & type is null", 0);
    return 0;
  } 
  result = (EventAssignment *)new EventAssignment((EventAssignment const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_EventAssignment_clone(void * jarg1) {
  void * jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  EventAssignment *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (EventAssignment *)((EventAssignment const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_EventAssignment_getVariable(void * jarg1) {
  wchar_t* jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  {
    std::string const &_result_ref = ((EventAssignment const *)arg1)->getVariable();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_EventAssignment_getMath(void * jarg1) {
  void * jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (ASTNode *)((EventAssignment const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_EventAssignment_isSetVariable(void * jarg1) {
  unsigned int jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  bool result;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (bool)((EventAssignment const *)arg1)->isSetVariable();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_EventAssignment_isSetMath(void * jarg1) {
  unsigned int jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  bool result;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (bool)((EventAssignment const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_EventAssignment_setVariable(void * jarg1, wchar_t* jarg2) {
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (EventAssignment *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->setVariable((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_EventAssignment_setMath(void * jarg1, void * jarg2) {
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_EventAssignment_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_EventAssignment_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  bool result;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_EventAssignment_getTypeCode(void * jarg1) {
  int jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (EventAssignment *)jarg1; 
  result = (SBMLTypeCode_t)((EventAssignment const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_EventAssignment_getElementName(void * jarg1) {
  wchar_t* jresult ;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (EventAssignment *)jarg1; 
  {
    std::string const &_result_ref = ((EventAssignment const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEventAssignments_clone(void * jarg1) {
  void * jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  ListOfEventAssignments *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  result = (ListOfEventAssignments *)((ListOfEventAssignments const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfEventAssignments_getTypeCode(void * jarg1) {
  int jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfEventAssignments const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ListOfEventAssignments_getItemTypeCode(void * jarg1) {
  int jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  result = (SBMLTypeCode_t)((ListOfEventAssignments const *)arg1)->getItemTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ListOfEventAssignments_getElementName(void * jarg1) {
  wchar_t* jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  {
    std::string const &_result_ref = ((ListOfEventAssignments const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEventAssignments_get__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  unsigned int arg2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (EventAssignment *)(arg1)->get(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEventAssignments_get__SWIG_2(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (EventAssignment *)(arg1)->get((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEventAssignments_remove__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  unsigned int arg2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (EventAssignment *)(arg1)->remove(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ListOfEventAssignments_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  EventAssignment *result = 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (EventAssignment *)(arg1)->remove((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ListOfEventAssignments() {
  void * jresult ;
  ListOfEventAssignments *result = 0 ;
  
  result = (ListOfEventAssignments *)new ListOfEventAssignments();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ListOfEventAssignments(void * jarg1) {
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  
  arg1 = (ListOfEventAssignments *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Trigger__SWIG_0(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  Trigger *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (Trigger *)new Trigger((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Trigger__SWIG_1() {
  void * jresult ;
  Trigger *result = 0 ;
  
  result = (Trigger *)new Trigger();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Trigger__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Trigger *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Trigger *)new Trigger(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Trigger__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Trigger *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Trigger *)new Trigger(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Trigger(void * jarg1) {
  Trigger *arg1 = (Trigger *) 0 ;
  
  arg1 = (Trigger *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Trigger__SWIG_4(void * jarg1) {
  void * jresult ;
  Trigger *arg1 = 0 ;
  Trigger *result = 0 ;
  
  arg1 = (Trigger *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Trigger const & type is null", 0);
    return 0;
  } 
  result = (Trigger *)new Trigger((Trigger const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Trigger_clone(void * jarg1) {
  void * jresult ;
  Trigger *arg1 = (Trigger *) 0 ;
  Trigger *result = 0 ;
  
  arg1 = (Trigger *)jarg1; 
  result = (Trigger *)((Trigger const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Trigger_getMath(void * jarg1) {
  void * jresult ;
  Trigger *arg1 = (Trigger *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (Trigger *)jarg1; 
  result = (ASTNode *)((Trigger const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Trigger_isSetMath(void * jarg1) {
  unsigned int jresult ;
  Trigger *arg1 = (Trigger *) 0 ;
  bool result;
  
  arg1 = (Trigger *)jarg1; 
  result = (bool)((Trigger const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Trigger_setMath(void * jarg1, void * jarg2) {
  Trigger *arg1 = (Trigger *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (Trigger *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Trigger_setSBMLDocument(void * jarg1, void * jarg2) {
  Trigger *arg1 = (Trigger *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (Trigger *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Trigger_setParentSBMLObject(void * jarg1, void * jarg2) {
  Trigger *arg1 = (Trigger *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (Trigger *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Trigger_getTypeCode(void * jarg1) {
  int jresult ;
  Trigger *arg1 = (Trigger *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Trigger *)jarg1; 
  result = (SBMLTypeCode_t)((Trigger const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Trigger_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Trigger *arg1 = (Trigger *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Trigger *)jarg1; 
  {
    std::string const &_result_ref = ((Trigger const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Delay__SWIG_0(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  Delay *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (Delay *)new Delay((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Delay__SWIG_1() {
  void * jresult ;
  Delay *result = 0 ;
  
  result = (Delay *)new Delay();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Delay__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  Delay *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (Delay *)new Delay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Delay__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Delay *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Delay *)new Delay(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Delay(void * jarg1) {
  Delay *arg1 = (Delay *) 0 ;
  
  arg1 = (Delay *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Delay__SWIG_4(void * jarg1) {
  void * jresult ;
  Delay *arg1 = 0 ;
  Delay *result = 0 ;
  
  arg1 = (Delay *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Delay const & type is null", 0);
    return 0;
  } 
  result = (Delay *)new Delay((Delay const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Delay_clone(void * jarg1) {
  void * jresult ;
  Delay *arg1 = (Delay *) 0 ;
  Delay *result = 0 ;
  
  arg1 = (Delay *)jarg1; 
  result = (Delay *)((Delay const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Delay_getMath(void * jarg1) {
  void * jresult ;
  Delay *arg1 = (Delay *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (Delay *)jarg1; 
  result = (ASTNode *)((Delay const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Delay_isSetMath(void * jarg1) {
  unsigned int jresult ;
  Delay *arg1 = (Delay *) 0 ;
  bool result;
  
  arg1 = (Delay *)jarg1; 
  result = (bool)((Delay const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Delay_setMath(void * jarg1, void * jarg2) {
  Delay *arg1 = (Delay *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (Delay *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Delay_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  Delay *arg1 = (Delay *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (Delay *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Delay_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  Delay *arg1 = (Delay *) 0 ;
  bool result;
  
  arg1 = (Delay *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Delay_setSBMLDocument(void * jarg1, void * jarg2) {
  Delay *arg1 = (Delay *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (Delay *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Delay_setParentSBMLObject(void * jarg1, void * jarg2) {
  Delay *arg1 = (Delay *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (Delay *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_Delay_getTypeCode(void * jarg1) {
  int jresult ;
  Delay *arg1 = (Delay *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (Delay *)jarg1; 
  result = (SBMLTypeCode_t)((Delay const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Delay_getElementName(void * jarg1) {
  wchar_t* jresult ;
  Delay *arg1 = (Delay *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Delay *)jarg1; 
  {
    std::string const &_result_ref = ((Delay const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_SBO_readTerm(void * jarg1, void * jarg2) {
  int jresult ;
  XMLAttributes *arg1 = 0 ;
  SBMLErrorLog *arg2 = (SBMLErrorLog *) 0 ;
  int result;
  
  arg1 = (XMLAttributes *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg2 = (SBMLErrorLog *)jarg2; 
  result = (int)SBO::readTerm((XMLAttributes const &)*arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBO_writeTerm(void * jarg1, int jarg2) {
  XMLOutputStream *arg1 = 0 ;
  int arg2 ;
  
  arg1 = (XMLOutputStream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLOutputStream & type is null", 0);
    return ;
  } 
  arg2 = (int)jarg2; 
  SBO::writeTerm(*arg1,arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isQuantitativeParameter(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isQuantitativeParameter(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isParticipantRole(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isParticipantRole(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isModellingFramework(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isModellingFramework(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isMathematicalExpression(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isMathematicalExpression(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isKineticConstant(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isKineticConstant(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isReactant(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isReactant(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isProduct(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isProduct(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isModifier(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isModifier(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isRateLaw(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isRateLaw(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isEvent(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isEvent(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isPhysicalParticipant(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isPhysicalParticipant(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isParticipant(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isParticipant(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isInteraction(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isInteraction(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isEntity(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isEntity(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isFunctionalEntity(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isFunctionalEntity(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isMaterialEntity(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isMaterialEntity(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isConservationLaw(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isConservationLaw(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isSteadyStateExpression(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isSteadyStateExpression(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isFunctionalCompartment(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isFunctionalCompartment(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isContinuousFramework(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isContinuousFramework(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isDiscreteFramework(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isDiscreteFramework(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isLogicalFramework(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isLogicalFramework(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBO_isObselete(long long jarg1) {
  unsigned int jresult ;
  unsigned int arg1 ;
  bool result;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (bool)SBO::isObselete(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_SBO_intToString(int jarg1) {
  wchar_t* jresult ;
  int arg1 ;
  std::string result;
  
  arg1 = (int)jarg1; 
  result = SBO::intToString(arg1);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBO() {
  void * jresult ;
  SBO *result = 0 ;
  
  result = (SBO *)new SBO();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBO(void * jarg1) {
  SBO *arg1 = (SBO *) 0 ;
  
  arg1 = (SBO *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StoichiometryMath__SWIG_0(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  StoichiometryMath *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (StoichiometryMath *)new StoichiometryMath((ASTNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StoichiometryMath__SWIG_1() {
  void * jresult ;
  StoichiometryMath *result = 0 ;
  
  result = (StoichiometryMath *)new StoichiometryMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StoichiometryMath__SWIG_2(long long jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  XMLNamespaces *arg3 = (XMLNamespaces *) 0 ;
  StoichiometryMath *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNamespaces *)jarg3; 
  result = (StoichiometryMath *)new StoichiometryMath(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StoichiometryMath__SWIG_3(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  StoichiometryMath *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (StoichiometryMath *)new StoichiometryMath(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_StoichiometryMath(void * jarg1) {
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StoichiometryMath__SWIG_4(void * jarg1) {
  void * jresult ;
  StoichiometryMath *arg1 = 0 ;
  StoichiometryMath *result = 0 ;
  
  arg1 = (StoichiometryMath *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StoichiometryMath const & type is null", 0);
    return 0;
  } 
  result = (StoichiometryMath *)new StoichiometryMath((StoichiometryMath const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StoichiometryMath_clone(void * jarg1) {
  void * jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  StoichiometryMath *result = 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (StoichiometryMath *)((StoichiometryMath const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StoichiometryMath_getMath(void * jarg1) {
  void * jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (ASTNode *)((StoichiometryMath const *)arg1)->getMath();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StoichiometryMath_isSetMath(void * jarg1) {
  unsigned int jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  bool result;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (bool)((StoichiometryMath const *)arg1)->isSetMath();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StoichiometryMath_setMath(void * jarg1, void * jarg2) {
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->setMath((ASTNode const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StoichiometryMath_getDerivedUnitDefinition(void * jarg1) {
  void * jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  UnitDefinition *result = 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StoichiometryMath_containsUndeclaredUnits(void * jarg1) {
  unsigned int jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  bool result;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (bool)(arg1)->containsUndeclaredUnits();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StoichiometryMath_setSBMLDocument(void * jarg1, void * jarg2) {
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  arg2 = (SBMLDocument *)jarg2; 
  (arg1)->setSBMLDocument(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_StoichiometryMath_setParentSBMLObject(void * jarg1, void * jarg2) {
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_StoichiometryMath_getTypeCode(void * jarg1) {
  int jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  SBMLTypeCode_t result;
  
  arg1 = (StoichiometryMath *)jarg1; 
  result = (SBMLTypeCode_t)((StoichiometryMath const *)arg1)->getTypeCode();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_StoichiometryMath_getElementName(void * jarg1) {
  wchar_t* jresult ;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (StoichiometryMath *)jarg1; 
  {
    std::string const &_result_ref = ((StoichiometryMath const *)arg1)->getElementName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_readMathMLFromString(wchar_t* jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  ASTNode_t *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (ASTNode_t *)readMathMLFromString((char const *)arg1);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_writeMathMLToString(void * jarg1) {
  wchar_t* jresult ;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  char *result = 0 ;
  
  arg1 = (ASTNode_t *)jarg1; 
  result = (char *)writeMathMLToString((ASTNode const *)arg1);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  free(result);
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ASTNode__SWIG_0(int jarg1) {
  void * jresult ;
  ASTNodeType_t arg1 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNodeType_t)jarg1; 
  result = (ASTNode *)new ASTNode(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ASTNode__SWIG_1() {
  void * jresult ;
  ASTNode *result = 0 ;
  
  result = (ASTNode *)new ASTNode();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ASTNode__SWIG_2(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ASTNode const & type is null", 0);
    return 0;
  } 
  result = (ASTNode *)new ASTNode((ASTNode const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ASTNode(void * jarg1) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_canonicalize(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)(arg1)->canonicalize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_addChild(void * jarg1, void * jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->addChild(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_prependChild(void * jarg1, void * jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->prependChild(arg2);
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASTNode_removeChild(void * jarg1, long long jarg2) {
  int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  int result;
  
  arg1 = (ASTNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (int)(arg1)->removeChild(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASTNode_replaceChild(void * jarg1, long long jarg2, void * jarg3) {
  int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  int result;
  
  arg1 = (ASTNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (ASTNode *)jarg3; 
  result = (int)(arg1)->replaceChild(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASTNode_insertChild(void * jarg1, long long jarg2, void * jarg3) {
  int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  int result;
  
  arg1 = (ASTNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (ASTNode *)jarg3; 
  result = (int)(arg1)->insertChild(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_deepCopy(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (ASTNode *)((ASTNode const *)arg1)->deepCopy();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getChild(void * jarg1, long long jarg2) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (ASTNode *)((ASTNode const *)arg1)->getChild(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getLeftChild(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (ASTNode *)((ASTNode const *)arg1)->getLeftChild();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getRightChild(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (ASTNode *)((ASTNode const *)arg1)->getRightChild();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_getNumChildren(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (unsigned int)((ASTNode const *)arg1)->getNumChildren();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_addSemanticsAnnotation(void * jarg1, void * jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (XMLNode *)jarg2; 
  (arg1)->addSemanticsAnnotation(arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_getNumSemanticsAnnotations(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (unsigned int)((ASTNode const *)arg1)->getNumSemanticsAnnotations();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getSemanticsAnnotation(void * jarg1, long long jarg2) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  XMLNode *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLNode *)((ASTNode const *)arg1)->getSemanticsAnnotation(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char SWIGSTDCALL CSharp_ASTNode_getCharacter(void * jarg1) {
  char jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  char result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (char)((ASTNode const *)arg1)->getCharacter();
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_ASTNode_getInteger(void * jarg1) {
  long jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (long)((ASTNode const *)arg1)->getInteger();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ASTNode_getName(void * jarg1) {
  wchar_t* jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  char *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (char *)((ASTNode const *)arg1)->getName();
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_ASTNode_getNumerator(void * jarg1) {
  long jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (long)((ASTNode const *)arg1)->getNumerator();
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_ASTNode_getDenominator(void * jarg1) {
  long jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (long)((ASTNode const *)arg1)->getDenominator();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_ASTNode_getReal(void * jarg1) {
  double jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  double result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (double)((ASTNode const *)arg1)->getReal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_ASTNode_getMantissa(void * jarg1) {
  double jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  double result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (double)((ASTNode const *)arg1)->getMantissa();
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_ASTNode_getExponent(void * jarg1) {
  long jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (long)((ASTNode const *)arg1)->getExponent();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASTNode_getPrecedence(void * jarg1) {
  int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  int result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (int)((ASTNode const *)arg1)->getPrecedence();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ASTNode_getType(void * jarg1) {
  int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (ASTNodeType_t)((ASTNode const *)arg1)->getType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isBoolean(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isBoolean();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isConstant(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isConstant();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isFunction(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isFunction();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isInfinity(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isInfinity();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isInteger(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isInteger();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isLambda(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isLambda();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isLog10(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isLog10();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isLogical(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isLogical();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isName(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isName();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isNaN(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isNaN();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isNegInfinity(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isNegInfinity();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isNumber(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isNumber();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isOperator(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isOperator();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isPiecewise(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isPiecewise();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isRational(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isRational();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isReal(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isReal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isRelational(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isRelational();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isSqrt(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isSqrt();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isUMinus(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isUMinus();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ASTNode_isUnknown(void * jarg1) {
  unsigned int jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  bool result;
  
  arg1 = (ASTNode *)jarg1; 
  result = (bool)((ASTNode const *)arg1)->isUnknown();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setCharacter(void * jarg1, char jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  char arg2 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (char)jarg2; 
  (arg1)->setCharacter(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setName(void * jarg1, wchar_t* jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToUTF8(jarg2);
      if (!arg2) return ;
    }
  }
  (arg1)->setName((char const *)arg2);
  {
    delete[] arg2;
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setValue__SWIG_0(void * jarg1, long jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  long arg2 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (long)jarg2; 
  (arg1)->setValue(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setValue__SWIG_1(void * jarg1, long jarg2, long jarg3) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  long arg2 ;
  long arg3 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (long)jarg2; 
  arg3 = (long)jarg3; 
  (arg1)->setValue(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setValue__SWIG_2(void * jarg1, double jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  double arg2 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (double)jarg2; 
  (arg1)->setValue(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setValue__SWIG_3(void * jarg1, double jarg2, long jarg3) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  double arg2 ;
  long arg3 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (long)jarg3; 
  (arg1)->setValue(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setType(void * jarg1, int jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t arg2 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (ASTNodeType_t)jarg2; 
  (arg1)->setType(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_swapChildren(void * jarg1, void * jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (ASTNode *)jarg2; 
  (arg1)->swapChildren(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getDefinitionURL(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  XMLAttributes *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (XMLAttributes *)((ASTNode const *)arg1)->getDefinitionURL();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_replaceArgument(void * jarg1, wchar_t* jarg2, void * jarg3) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  arg3 = (ASTNode *)jarg3; 
  (arg1)->replaceArgument(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_ReplaceArgument(void * jarg1, wchar_t* jarg2, void * jarg3) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  arg3 = (ASTNode *)jarg3; 
  (arg1)->ReplaceArgument(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_setParentSBMLObject(void * jarg1, void * jarg2) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  arg2 = (SBase *)jarg2; 
  (arg1)->setParentSBMLObject(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ASTNode_getParentSBMLObject(void * jarg1) {
  void * jresult ;
  ASTNode *arg1 = (ASTNode *) 0 ;
  SBase *result = 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  result = (SBase *)((ASTNode const *)arg1)->getParentSBMLObject();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_ReduceToBinary(void * jarg1) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  (arg1)->ReduceToBinary();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ASTNode_reduceToBinary(void * jarg1) {
  ASTNode *arg1 = (ASTNode *) 0 ;
  
  arg1 = (ASTNode *)jarg1; 
  (arg1)->reduceToBinary();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_parseFormula(wchar_t* jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  ASTNode_t *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (ASTNode_t *)SBML_parseFormula((char const *)arg1);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_formulaToString(void * jarg1) {
  wchar_t* jresult ;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  char *result = 0 ;
  
  arg1 = (ASTNode_t *)jarg1; 
  result = (char *)SBML_formulaToString((ASTNode const *)arg1);
  {
    jresult = convertUTF8ToUnicode( result );
    wchar_t* unistr = convertUTF8ToUnicode( result );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  free(result);
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLAttributes__SWIG_0() {
  void * jresult ;
  XMLAttributes *result = 0 ;
  
  result = (XMLAttributes *)new XMLAttributes();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLAttributes(void * jarg1) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLAttributes__SWIG_1(void * jarg1) {
  void * jresult ;
  XMLAttributes *arg1 = 0 ;
  XMLAttributes *result = 0 ;
  
  arg1 = (XMLAttributes *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  result = (XMLAttributes *)new XMLAttributes((XMLAttributes const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLAttributes_clone(void * jarg1) {
  void * jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLAttributes *result = 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  result = (XMLAttributes *)((XMLAttributes const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_add__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3, wchar_t* jarg4, wchar_t* jarg5) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  std::string arg_str4 ;
  std::string arg_str5 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return ;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  (arg1)->add((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_add__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3, wchar_t* jarg4) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  std::string arg_str4 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return ;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  (arg1)->add((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_add__SWIG_2(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->add((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_add__SWIG_3(void * jarg1, void * jarg2, wchar_t* jarg3) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str3 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->add((XMLTriple const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_addResource(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->addResource((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_removeResource(void * jarg1, int jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->removeResource(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_remove__SWIG_0(void * jarg1, int jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->remove(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_remove__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->remove((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_remove__SWIG_2(void * jarg1, wchar_t* jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->remove((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_remove__SWIG_3(void * jarg1, void * jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->remove((XMLTriple const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_clear(void * jarg1) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLAttributes_getIndex__SWIG_0(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  int result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (int)((XMLAttributes const *)arg1)->getIndex((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLAttributes_getIndex__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  int result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (int)((XMLAttributes const *)arg1)->getIndex((std::string const &)*arg2,(std::string const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLAttributes_getIndex__SWIG_2(void * jarg1, void * jarg2) {
  int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  int result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (int)((XMLAttributes const *)arg1)->getIndex((XMLTriple const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLAttributes_getLength(void * jarg1) {
  int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int result;
  
  arg1 = (XMLAttributes *)jarg1; 
  result = (int)((XMLAttributes const *)arg1)->getLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getName(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLAttributes const *)arg1)->getName(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getPrefix(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLAttributes const *)arg1)->getPrefix(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getPrefixedName(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLAttributes const *)arg1)->getPrefixedName(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getURI(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLAttributes const *)arg1)->getURI(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getValue__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLAttributes const *)arg1)->getValue(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getValue__SWIG_1(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string arg2 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = ((XMLAttributes const *)arg1)->getValue(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getValue__SWIG_2(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  result = ((XMLAttributes const *)arg1)->getValue(arg2,arg3);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLAttributes_getValue__SWIG_3(void * jarg1, void * jarg2) {
  wchar_t* jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = ((XMLAttributes const *)arg1)->getValue((XMLTriple const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLAttributes_hasAttribute__SWIG_0(void * jarg1, int jarg2) {
  unsigned int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLAttributes_hasAttribute__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  unsigned int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLAttributes_hasAttribute__SWIG_2(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (XMLAttributes *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLAttributes_hasAttribute__SWIG_3(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool result;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute((XMLTriple const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLAttributes_isEmpty(void * jarg1) {
  unsigned int jresult ;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  bool result;
  
  arg1 = (XMLAttributes *)jarg1; 
  result = (bool)((XMLAttributes const *)arg1)->isEmpty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_write(void * jarg1, void * jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLOutputStream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLOutputStream & type is null", 0);
    return ;
  } 
  ((XMLAttributes const *)arg1)->write(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLAttributes_setErrorLog(void * jarg1, void * jarg2) {
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLErrorLog *arg2 = (XMLErrorLog *) 0 ;
  
  arg1 = (XMLAttributes *)jarg1; 
  arg2 = (XMLErrorLog *)jarg2; 
  (arg1)->setErrorLog(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNamespaces__SWIG_0() {
  void * jresult ;
  XMLNamespaces *result = 0 ;
  
  result = (XMLNamespaces *)new XMLNamespaces();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLNamespaces(void * jarg1) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNamespaces__SWIG_1(void * jarg1) {
  void * jresult ;
  XMLNamespaces *arg1 = 0 ;
  XMLNamespaces *result = 0 ;
  
  arg1 = (XMLNamespaces *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  result = (XMLNamespaces *)new XMLNamespaces((XMLNamespaces const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNamespaces_clone(void * jarg1) {
  void * jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  XMLNamespaces *result = 0 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  result = (XMLNamespaces *)((XMLNamespaces const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNamespaces_add__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->add((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNamespaces_add__SWIG_1(void * jarg1, wchar_t* jarg2) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->add((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNamespaces_remove__SWIG_0(void * jarg1, int jarg2) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->remove(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNamespaces_remove__SWIG_1(void * jarg1, wchar_t* jarg2) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->remove((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNamespaces_clear(void * jarg1) {
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  
  arg1 = (XMLNamespaces *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLNamespaces_getIndex(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string arg2 ;
  int result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (int)((XMLNamespaces const *)arg1)->getIndex(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLNamespaces_getIndexByPrefix(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string arg2 ;
  int result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (int)((XMLNamespaces const *)arg1)->getIndexByPrefix(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLNamespaces_getLength(void * jarg1) {
  int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  result = (int)((XMLNamespaces const *)arg1)->getLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNamespaces_getPrefix__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLNamespaces const *)arg1)->getPrefix(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNamespaces_getPrefix__SWIG_1(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  std::string result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = ((XMLNamespaces const *)arg1)->getPrefix((std::string const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNamespaces_getURI__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLNamespaces const *)arg1)->getURI(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNamespaces_getURI__SWIG_1(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  std::string result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = ((XMLNamespaces const *)arg1)->getURI((std::string const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNamespaces_getURI__SWIG_2(void * jarg1) {
  wchar_t* jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  result = ((XMLNamespaces const *)arg1)->getURI();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLNamespaces_isEmpty(void * jarg1) {
  unsigned int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  bool result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  result = (bool)((XMLNamespaces const *)arg1)->isEmpty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLNamespaces_hasURI(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  bool result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasURI((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLNamespaces_hasPrefix(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  bool result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasPrefix((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLNamespaces_hasNS(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  unsigned int jresult ;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  bool result;
  
  arg1 = (XMLNamespaces *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasNS((std::string const &)*arg2,(std::string const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_0() {
  void * jresult ;
  XMLToken *result = 0 ;
  
  result = (XMLToken *)new XMLToken();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_1(void * jarg1, void * jarg2, void * jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_2(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_4(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_5(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_6(void * jarg1, void * jarg2) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_7(void * jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_8(void * jarg1, long long jarg2) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_9(void * jarg1) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_10(wchar_t* jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg_str1 ;
  XMLToken *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLToken *)new XMLToken((std::string const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_11(wchar_t* jarg1, long long jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  std::string arg_str1 ;
  XMLToken *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLToken *)new XMLToken((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_12(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  XMLToken *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (XMLToken *)new XMLToken((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLToken(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLToken__SWIG_13(void * jarg1) {
  void * jresult ;
  XMLToken *arg1 = 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLToken *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return 0;
  } 
  result = (XMLToken *)new XMLToken((XMLToken const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLToken_clone(void * jarg1) {
  void * jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  result = (XMLToken *)((XMLToken const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLToken_getAttributes(void * jarg1) {
  void * jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLAttributes *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    XMLAttributes const &_result_ref = ((XMLToken const *)arg1)->getAttributes();
    result = (XMLAttributes *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_setAttributes(void * jarg1, void * jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLAttributes *arg2 = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return ;
  } 
  (arg1)->setAttributes((XMLAttributes const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addAttr__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3, wchar_t* jarg4, wchar_t* jarg5) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  std::string arg_str4 ;
  std::string arg_str5 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return ;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  (arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addAttr__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3, wchar_t* jarg4) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  std::string arg_str4 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return ;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  (arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addAttr__SWIG_2(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addAttr__SWIG_3(void * jarg1, void * jarg2, wchar_t* jarg3) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str3 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->addAttr((XMLTriple const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeAttr__SWIG_0(void * jarg1, int jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->removeAttr(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeAttr__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->removeAttr((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeAttr__SWIG_2(void * jarg1, wchar_t* jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->removeAttr((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeAttr__SWIG_3(void * jarg1, void * jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->removeAttr((XMLTriple const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_clearAttributes(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  (arg1)->clearAttributes();
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getAttrIndex__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (int)((XMLToken const *)arg1)->getAttrIndex((std::string const &)*arg2,(std::string const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getAttrIndex__SWIG_1(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (int)((XMLToken const *)arg1)->getAttrIndex((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getAttrIndex__SWIG_2(void * jarg1, void * jarg2) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (int)((XMLToken const *)arg1)->getAttrIndex((XMLTriple const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getAttributesLength(void * jarg1) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (int)((XMLToken const *)arg1)->getAttributesLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrName(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getAttrName(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrPrefix(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getAttrPrefix(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrPrefixedName(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getAttrPrefixedName(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrURI(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getAttrURI(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrValue__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getAttrValue(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrValue__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  result = ((XMLToken const *)arg1)->getAttrValue(arg2,arg3);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrValue__SWIG_2(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = ((XMLToken const *)arg1)->getAttrValue(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getAttrValue__SWIG_3(void * jarg1, void * jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = ((XMLToken const *)arg1)->getAttrValue((XMLTriple const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasAttr__SWIG_0(void * jarg1, int jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)((XMLToken const *)arg1)->hasAttr(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasAttr__SWIG_1(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  result = (bool)((XMLToken const *)arg1)->hasAttr(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasAttr__SWIG_2(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (bool)((XMLToken const *)arg1)->hasAttr(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasAttr__SWIG_3(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (bool)((XMLToken const *)arg1)->hasAttr((XMLTriple const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isAttributesEmpty(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isAttributesEmpty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLToken_getNamespaces(void * jarg1) {
  void * jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLNamespaces *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    XMLNamespaces const &_result_ref = ((XMLToken const *)arg1)->getNamespaces();
    result = (XMLNamespaces *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_setNamespaces(void * jarg1, void * jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLNamespaces *arg2 = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLNamespaces *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return ;
  } 
  (arg1)->setNamespaces((XMLNamespaces const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addNamespace__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->addNamespace((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_addNamespace__SWIG_1(void * jarg1, wchar_t* jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->addNamespace((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeNamespace__SWIG_0(void * jarg1, int jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->removeNamespace(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_removeNamespace__SWIG_1(void * jarg1, wchar_t* jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->removeNamespace((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_clearNamespaces(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  (arg1)->clearNamespaces();
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getNamespaceIndex(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (int)((XMLToken const *)arg1)->getNamespaceIndex((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getNamespaceIndexByPrefix(void * jarg1, wchar_t* jarg2) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (int)((XMLToken const *)arg1)->getNamespaceIndexByPrefix((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XMLToken_getNamespacesLength(void * jarg1) {
  int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (int)((XMLToken const *)arg1)->getNamespacesLength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getNamespacePrefix__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getNamespacePrefix(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getNamespacePrefix__SWIG_1(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = ((XMLToken const *)arg1)->getNamespacePrefix((std::string const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getNamespaceURI__SWIG_0(void * jarg1, int jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((XMLToken const *)arg1)->getNamespaceURI(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getNamespaceURI__SWIG_1(void * jarg1, wchar_t* jarg2) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = ((XMLToken const *)arg1)->getNamespaceURI((std::string const &)*arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getNamespaceURI__SWIG_2(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  result = ((XMLToken const *)arg1)->getNamespaceURI();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isNamespacesEmpty(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isNamespacesEmpty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasNamespaceURI(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespaceURI((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasNamespacePrefix(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespacePrefix((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_hasNamespaceNS(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespaceNS((std::string const &)*arg2,(std::string const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_setTriple(void * jarg1, void * jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->setTriple((XMLTriple const &)*arg2);
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getName(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    std::string const &_result_ref = ((XMLToken const *)arg1)->getName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getPrefix(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    std::string const &_result_ref = ((XMLToken const *)arg1)->getPrefix();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getURI(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    std::string const &_result_ref = ((XMLToken const *)arg1)->getURI();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_getCharacters(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    std::string const &_result_ref = ((XMLToken const *)arg1)->getCharacters();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_append(void * jarg1, wchar_t* jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLToken *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->append((std::string const &)*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_getColumn(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  unsigned int result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (unsigned int)((XMLToken const *)arg1)->getColumn();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_getLine(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  unsigned int result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (unsigned int)((XMLToken const *)arg1)->getLine();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isElement(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isElement();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isEnd(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isEnd();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isEndFor(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLToken *arg2 = 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return 0;
  } 
  result = (bool)((XMLToken const *)arg1)->isEndFor((XMLToken const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isEOF(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isEOF();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isStart(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isStart();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLToken_isText(void * jarg1) {
  unsigned int jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  bool result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (bool)((XMLToken const *)arg1)->isText();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_setEnd(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  (arg1)->setEnd();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_setEOF(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  (arg1)->setEOF();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_unsetEnd(void * jarg1) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  (arg1)->unsetEnd();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLToken_write(void * jarg1, void * jarg2) {
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  
  arg1 = (XMLToken *)jarg1; 
  arg2 = (XMLOutputStream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLOutputStream & type is null", 0);
    return ;
  } 
  ((XMLToken const *)arg1)->write(*arg2);
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLToken_toString(void * jarg1) {
  wchar_t* jresult ;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string result;
  
  arg1 = (XMLToken *)jarg1; 
  result = (arg1)->toString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_0() {
  void * jresult ;
  XMLNode *result = 0 ;
  
  result = (XMLNode *)new XMLNode();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_1(void * jarg1) {
  void * jresult ;
  XMLToken *arg1 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLToken *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode((XMLToken const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_2(void * jarg1, void * jarg2, void * jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_3(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  arg3 = (XMLNamespaces *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNamespaces const & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_5(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_6(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_7(void * jarg1, void * jarg2) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  arg2 = (XMLAttributes *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLAttributes const & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_8(void * jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_9(void * jarg1, long long jarg2) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_10(void * jarg1) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_11(wchar_t* jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg_str1 ;
  XMLNode *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLNode *)new XMLNode((std::string const &)*arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_12(wchar_t* jarg1, long long jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  std::string arg_str1 ;
  XMLNode *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLNode *)new XMLNode((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_13(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  XMLNode *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (XMLNode *)new XMLNode((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_14(void * jarg1) {
  void * jresult ;
  XMLInputStream *arg1 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLInputStream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLInputStream & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode(*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLNode(void * jarg1) {
  XMLNode *arg1 = (XMLNode *) 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLNode__SWIG_15(void * jarg1) {
  void * jresult ;
  XMLNode *arg1 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNode const & type is null", 0);
    return 0;
  } 
  result = (XMLNode *)new XMLNode((XMLNode const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_clone(void * jarg1) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  result = (XMLNode *)((XMLNode const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNode_addChild(void * jarg1, void * jarg2) {
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *arg2 = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  arg2 = (XMLNode *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNode const & type is null", 0);
    return ;
  } 
  (arg1)->addChild((XMLNode const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_insertChild(void * jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  XMLNode *arg3 = 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  arg3 = (XMLNode *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLNode const & type is null", 0);
    return 0;
  } 
  {
    XMLNode &_result_ref = (arg1)->insertChild(arg2,(XMLNode const &)*arg3);
    result = (XMLNode *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_removeChild(void * jarg1, long long jarg2) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLNode *)(arg1)->removeChild(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNode_removeChildren(void * jarg1) {
  XMLNode *arg1 = (XMLNode *) 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  (arg1)->removeChildren();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_getChild__SWIG_0(void * jarg1, long long jarg2) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    XMLNode &_result_ref = (arg1)->getChild(arg2);
    result = (XMLNode *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLNode_getNumChildren(void * jarg1) {
  unsigned int jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int result;
  
  arg1 = (XMLNode *)jarg1; 
  result = (unsigned int)((XMLNode const *)arg1)->getNumChildren();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLNode_write(void * jarg1, void * jarg2) {
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  arg2 = (XMLOutputStream *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLOutputStream & type is null", 0);
    return ;
  } 
  ((XMLNode const *)arg1)->write(*arg2);
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNode_toXMLString(void * jarg1) {
  wchar_t* jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string result;
  
  arg1 = (XMLNode *)jarg1; 
  result = ((XMLNode const *)arg1)->toXMLString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLNode_convertXMLNodeToString(void * jarg1) {
  wchar_t* jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string result;
  
  arg1 = (XMLNode *)jarg1; 
  result = XMLNode::convertXMLNodeToString((XMLNode const *)arg1);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_convertStringToXMLNode__SWIG_0(wchar_t* jarg1, void * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  std::string arg_str1 ;
  XMLNode *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (XMLNamespaces *)jarg2; 
  result = (XMLNode *)XMLNode::convertStringToXMLNode((std::string const &)*arg1,(XMLNamespaces const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLNode_convertStringToXMLNode__SWIG_1(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  XMLNode *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (XMLNode *)XMLNode::convertStringToXMLNode((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTriple__SWIG_0() {
  void * jresult ;
  XMLTriple *result = 0 ;
  
  result = (XMLTriple *)new XMLTriple();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTriple__SWIG_1(wchar_t* jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str1 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  XMLTriple *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return 0;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTriple__SWIG_2(wchar_t* jarg1, char jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  char arg2 ;
  std::string arg_str1 ;
  XMLTriple *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  arg2 = (char)jarg2; 
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTriple__SWIG_3(wchar_t* jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string arg_str1 ;
  XMLTriple *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    if (!mbstr) return 0;
    
    arg_str1.assign(mbstr);
    arg1 = &arg_str1;
    delete[] mbstr;
  }
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTriple__SWIG_4(void * jarg1) {
  void * jresult ;
  XMLTriple *arg1 = 0 ;
  XMLTriple *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return 0;
  } 
  result = (XMLTriple *)new XMLTriple((XMLTriple const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLTriple_clone(void * jarg1) {
  void * jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  XMLTriple *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1; 
  result = (XMLTriple *)((XMLTriple const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTriple_getName(void * jarg1) {
  wchar_t* jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1; 
  {
    std::string const &_result_ref = ((XMLTriple const *)arg1)->getName();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTriple_getPrefix(void * jarg1) {
  wchar_t* jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1; 
  {
    std::string const &_result_ref = ((XMLTriple const *)arg1)->getPrefix();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTriple_getURI(void * jarg1) {
  wchar_t* jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLTriple *)jarg1; 
  {
    std::string const &_result_ref = ((XMLTriple const *)arg1)->getURI();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTriple_getPrefixedName(void * jarg1) {
  wchar_t* jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  std::string result;
  
  arg1 = (XMLTriple *)jarg1; 
  result = ((XMLTriple const *)arg1)->getPrefixedName();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLTriple_isEmpty(void * jarg1) {
  unsigned int jresult ;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  bool result;
  
  arg1 = (XMLTriple *)jarg1; 
  result = (bool)((XMLTriple const *)arg1)->isEmpty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLTriple(void * jarg1) {
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  
  arg1 = (XMLTriple *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLInputStream__SWIG_0(wchar_t* jarg1, unsigned int jarg2, wchar_t* jarg3, void * jarg4) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  XMLErrorLog *arg4 = (XMLErrorLog *) 0 ;
  XMLInputStream *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  arg2 = jarg2 ? true : false; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  arg4 = (XMLErrorLog *)jarg4; 
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLInputStream__SWIG_1(wchar_t* jarg1, unsigned int jarg2, wchar_t* jarg3) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  XMLInputStream *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  arg2 = jarg2 ? true : false; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    (&arg3)->assign(mbstr);
    delete[] mbstr;
  }
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2,arg3);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLInputStream__SWIG_2(wchar_t* jarg1, unsigned int jarg2) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  XMLInputStream *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  arg2 = jarg2 ? true : false; 
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLInputStream__SWIG_3(wchar_t* jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  XMLInputStream *result = 0 ;
  
  {
    if (jarg1)
    {
      arg1 = convertUnicodeToUTF8(jarg1);
      if (!arg1) return 0;
    }
  }
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1);
  jresult = (void *)result; 
  {
    delete[] arg1;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLInputStream(void * jarg1) {
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  delete arg1;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLInputStream_getEncoding(void * jarg1) {
  wchar_t* jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  {
    std::string const &_result_ref = (arg1)->getEncoding();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLInputStream_getVersion(void * jarg1) {
  wchar_t* jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  {
    std::string const &_result_ref = (arg1)->getVersion();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLInputStream_getErrorLog(void * jarg1) {
  void * jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLErrorLog *result = 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (XMLErrorLog *)(arg1)->getErrorLog();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLInputStream_isEOF(void * jarg1) {
  unsigned int jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  bool result;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (bool)((XMLInputStream const *)arg1)->isEOF();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLInputStream_isError(void * jarg1) {
  unsigned int jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  bool result;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (bool)((XMLInputStream const *)arg1)->isError();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLInputStream_isGood(void * jarg1) {
  unsigned int jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  bool result;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (bool)((XMLInputStream const *)arg1)->isGood();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLInputStream_next(void * jarg1) {
  void * jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLToken result;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (arg1)->next();
  jresult = new XMLToken((const XMLToken &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLInputStream_peek(void * jarg1) {
  void * jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  {
    XMLToken const &_result_ref = (arg1)->peek();
    result = (XMLToken *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLInputStream_skipPastEnd(void * jarg1, void * jarg2) {
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->skipPastEnd((XMLToken const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLInputStream_skipText(void * jarg1) {
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  (arg1)->skipText();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLInputStream_setErrorLog(void * jarg1, void * jarg2) {
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLErrorLog *arg2 = (XMLErrorLog *) 0 ;
  
  arg1 = (XMLInputStream *)jarg1; 
  arg2 = (XMLErrorLog *)jarg2; 
  (arg1)->setErrorLog(arg2);
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLInputStream_toString(void * jarg1) {
  wchar_t* jresult ;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string result;
  
  arg1 = (XMLInputStream *)jarg1; 
  result = (arg1)->toString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLOutputStream__SWIG_0(void * jarg1, wchar_t* jarg2, unsigned int jarg3, wchar_t* jarg4, wchar_t* jarg5) {
  void * jresult ;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string arg_str2 ;
  std::string arg_str4 ;
  std::string arg_str5 ;
  XMLOutputStream *result = 0 ;
  
  arg1 = (std::ostream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = jarg3 ? true : false; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return 0;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  result = (XMLOutputStream *)new XMLOutputStream(*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLOutputStream__SWIG_1(void * jarg1, wchar_t* jarg2, unsigned int jarg3, wchar_t* jarg4) {
  void * jresult ;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  std::string *arg4 = 0 ;
  std::string arg_str2 ;
  std::string arg_str4 ;
  XMLOutputStream *result = 0 ;
  
  arg1 = (std::ostream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = jarg3 ? true : false; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  result = (XMLOutputStream *)new XMLOutputStream(*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLOutputStream__SWIG_2(void * jarg1, wchar_t* jarg2, unsigned int jarg3) {
  void * jresult ;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  std::string arg_str2 ;
  XMLOutputStream *result = 0 ;
  
  arg1 = (std::ostream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  arg3 = jarg3 ? true : false; 
  result = (XMLOutputStream *)new XMLOutputStream(*arg1,(std::string const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLOutputStream__SWIG_3(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  XMLOutputStream *result = 0 ;
  
  arg1 = (std::ostream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (XMLOutputStream *)new XMLOutputStream(*arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLOutputStream__SWIG_4(void * jarg1) {
  void * jresult ;
  std::ostream *arg1 = 0 ;
  XMLOutputStream *result = 0 ;
  
  arg1 = (std::ostream *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return 0;
  } 
  result = (XMLOutputStream *)new XMLOutputStream(*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_endElement__SWIG_0(void * jarg1, wchar_t* jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->endElement((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_endElement__SWIG_1(void * jarg1, void * jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->endElement((XMLTriple const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_setAutoIndent(void * jarg1, unsigned int jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  bool arg2 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->setAutoIndent(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_startElement__SWIG_0(void * jarg1, wchar_t* jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->startElement((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_startElement__SWIG_1(void * jarg1, void * jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->startElement((XMLTriple const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_startEndElement__SWIG_0(void * jarg1, wchar_t* jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  (arg1)->startEndElement((std::string const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_startEndElement__SWIG_1(void * jarg1, void * jarg2) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  (arg1)->startEndElement((XMLTriple const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_0(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_1(void * jarg1, void * jarg2, wchar_t* jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_2(void * jarg1, wchar_t* jarg2, unsigned int jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  bool *arg3 = 0 ;
  std::string arg_str2 ;
  bool temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((std::string const &)*arg2,(bool const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool *arg3 = 0 ;
  bool temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(bool const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_4(void * jarg1, wchar_t* jarg2, double jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  std::string arg_str2 ;
  double temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((std::string const &)*arg2,(double const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_5(void * jarg1, void * jarg2, double jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  double *arg3 = 0 ;
  double temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(double const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_6(void * jarg1, wchar_t* jarg2, long jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  long *arg3 = 0 ;
  std::string arg_str2 ;
  long temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((std::string const &)*arg2,(long const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeAttribute__SWIG_7(void * jarg1, void * jarg2, long jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  arg2 = (XMLTriple *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLTriple const & type is null", 0);
    return ;
  } 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(long const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeXMLDecl(void * jarg1) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  (arg1)->writeXMLDecl();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_writeComment(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->writeComment((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_downIndent(void * jarg1) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  (arg1)->downIndent();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLOutputStream_upIndent(void * jarg1) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  (arg1)->upIndent();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLOutputStream_getStringStream(void * jarg1) {
  unsigned int jresult ;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  bool result;
  
  arg1 = (XMLOutputStream *)jarg1; 
  result = (bool)(arg1)->getStringStream();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLOutputStream(void * jarg1) {
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  
  arg1 = (XMLOutputStream *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_0(int jarg1, wchar_t* jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6) {
  void * jresult ;
  int arg1 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg_str2 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  result = (XMLError *)new XMLError(arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_1(int jarg1, wchar_t* jarg2, long long jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  int arg1 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  std::string arg_str2 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  result = (XMLError *)new XMLError(arg1,(std::string const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_2(int jarg1, wchar_t* jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  int arg1 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg_str2 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (XMLError *)new XMLError(arg1,(std::string const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_3(int jarg1, wchar_t* jarg2, long long jarg3) {
  void * jresult ;
  int arg1 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  std::string arg_str2 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (XMLError *)new XMLError(arg1,(std::string const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_4(int jarg1, wchar_t* jarg2) {
  void * jresult ;
  int arg1 ;
  std::string *arg2 = 0 ;
  std::string arg_str2 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return 0;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  result = (XMLError *)new XMLError(arg1,(std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_5(int jarg1) {
  void * jresult ;
  int arg1 ;
  XMLError *result = 0 ;
  
  arg1 = (int)jarg1; 
  result = (XMLError *)new XMLError(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_6() {
  void * jresult ;
  XMLError *result = 0 ;
  
  result = (XMLError *)new XMLError();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLError__SWIG_7(void * jarg1) {
  void * jresult ;
  XMLError *arg1 = 0 ;
  XMLError *result = 0 ;
  
  arg1 = (XMLError *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLError const & type is null", 0);
    return 0;
  } 
  result = (XMLError *)new XMLError((XMLError const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLError(void * jarg1) {
  XMLError *arg1 = (XMLError *) 0 ;
  
  arg1 = (XMLError *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_getErrorId(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int result;
  
  arg1 = (XMLError *)jarg1; 
  result = (unsigned int)((XMLError const *)arg1)->getErrorId();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLError_getMessage(void * jarg1) {
  wchar_t* jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    std::string const &_result_ref = ((XMLError const *)arg1)->getMessage();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLError_getShortMessage(void * jarg1) {
  wchar_t* jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    std::string const &_result_ref = ((XMLError const *)arg1)->getShortMessage();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_getLine(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int result;
  
  arg1 = (XMLError *)jarg1; 
  result = (unsigned int)((XMLError const *)arg1)->getLine();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_getColumn(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int result;
  
  arg1 = (XMLError *)jarg1; 
  result = (unsigned int)((XMLError const *)arg1)->getColumn();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_getSeverity(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int result;
  
  arg1 = (XMLError *)jarg1; 
  result = (unsigned int)((XMLError const *)arg1)->getSeverity();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLError_getSeverityAsString(void * jarg1) {
  wchar_t* jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    std::string const &_result_ref = ((XMLError const *)arg1)->getSeverityAsString();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_getCategory(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int result;
  
  arg1 = (XMLError *)jarg1; 
  result = (unsigned int)((XMLError const *)arg1)->getCategory();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLError_getCategoryAsString(void * jarg1) {
  wchar_t* jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    std::string const &_result_ref = ((XMLError const *)arg1)->getCategoryAsString();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isInfo(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isInfo();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isWarning(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isWarning();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isError(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isError();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isFatal(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isFatal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isInternal(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isInternal();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isSystem(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isSystem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLError_isXML(void * jarg1) {
  unsigned int jresult ;
  XMLError *arg1 = (XMLError *) 0 ;
  bool result;
  
  arg1 = (XMLError *)jarg1; 
  result = (bool)((XMLError const *)arg1)->isXML();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLError_setLine(void * jarg1, long long jarg2) {
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setLine(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLError_setColumn(void * jarg1, long long jarg2) {
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (XMLError *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setColumn(arg2);
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLError_getStandardMessage(int jarg1) {
  wchar_t* jresult ;
  int arg1 ;
  std::string result;
  
  arg1 = (int)jarg1; 
  result = XMLError::getStandardMessage(arg1);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLErrorLog_getNumErrors(void * jarg1) {
  unsigned int jresult ;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  unsigned int result;
  
  arg1 = (XMLErrorLog *)jarg1; 
  result = (unsigned int)((XMLErrorLog const *)arg1)->getNumErrors();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLErrorLog_getError(void * jarg1, long long jarg2) {
  void * jresult ;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  unsigned int arg2 ;
  XMLError *result = 0 ;
  
  arg1 = (XMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (XMLError *)((XMLErrorLog const *)arg1)->getError(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLErrorLog_clearLog(void * jarg1) {
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  
  arg1 = (XMLErrorLog *)jarg1; 
  (arg1)->clearLog();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLErrorLog() {
  void * jresult ;
  XMLErrorLog *result = 0 ;
  
  result = (XMLErrorLog *)new XMLErrorLog();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLErrorLog(void * jarg1) {
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  
  arg1 = (XMLErrorLog *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLErrorLog_add(void * jarg1, void * jarg2) {
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLError *arg2 = 0 ;
  
  arg1 = (XMLErrorLog *)jarg1; 
  arg2 = (XMLError *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLError const & type is null", 0);
    return ;
  } 
  (arg1)->add((XMLError const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLErrorLog_setParser(void * jarg1, void * jarg2) {
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLParser *arg2 = (XMLParser *) 0 ;
  
  arg1 = (XMLErrorLog *)jarg1; 
  arg2 = (XMLParser *)jarg2; 
  (arg1)->setParser((XMLParser const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLHandler() {
  void * jresult ;
  XMLHandler *result = 0 ;
  
  result = (XMLHandler *)new XMLHandler();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLHandler(void * jarg1) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_startDocument(void * jarg1) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  (arg1)->startDocument();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_XML(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLHandler *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->XML((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_startElement(void * jarg1, void * jarg2) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->startElement((XMLToken const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_endDocument(void * jarg1) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  (arg1)->endDocument();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_endElement(void * jarg1, void * jarg2) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->endElement((XMLToken const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLHandler_characters(void * jarg1, void * jarg2) {
  XMLHandler *arg1 = (XMLHandler *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLHandler *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->characters((XMLToken const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLParser_create__SWIG_0(void * jarg1, wchar_t* jarg2) {
  void * jresult ;
  XMLHandler *arg1 = 0 ;
  std::string arg2 ;
  XMLParser *result = 0 ;
  
  arg1 = (XMLHandler *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLHandler & type is null", 0);
    return 0;
  } 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  result = (XMLParser *)XMLParser::create(*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLParser_create__SWIG_1(void * jarg1) {
  void * jresult ;
  XMLHandler *arg1 = 0 ;
  XMLParser *result = 0 ;
  
  arg1 = (XMLHandler *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLHandler & type is null", 0);
    return 0;
  } 
  result = (XMLParser *)XMLParser::create(*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLParser(void * jarg1) {
  XMLParser *arg1 = (XMLParser *) 0 ;
  
  arg1 = (XMLParser *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_parse__SWIG_0(void * jarg1, wchar_t* jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  bool result;
  
  arg1 = (XMLParser *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToUTF8(jarg2);
      if (!arg2) return 0;
    }
  }
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->parse((char const *)arg2,arg3);
  jresult = result; 
  {
    delete[] arg2;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_parse__SWIG_1(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (XMLParser *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToUTF8(jarg2);
      if (!arg2) return 0;
    }
  }
  result = (bool)(arg1)->parse((char const *)arg2);
  jresult = result; 
  {
    delete[] arg2;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_parseFirst__SWIG_0(void * jarg1, wchar_t* jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  bool result;
  
  arg1 = (XMLParser *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToUTF8(jarg2);
      if (!arg2) return 0;
    }
  }
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->parseFirst((char const *)arg2,arg3);
  jresult = result; 
  {
    delete[] arg2;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_parseFirst__SWIG_1(void * jarg1, wchar_t* jarg2) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (XMLParser *)jarg1; 
  {
    if (jarg2)
    {
      arg2 = convertUnicodeToUTF8(jarg2);
      if (!arg2) return 0;
    }
  }
  result = (bool)(arg1)->parseFirst((char const *)arg2);
  jresult = result; 
  {
    delete[] arg2;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_parseNext(void * jarg1) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  bool result;
  
  arg1 = (XMLParser *)jarg1; 
  result = (bool)(arg1)->parseNext();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLParser_parseReset(void * jarg1) {
  XMLParser *arg1 = (XMLParser *) 0 ;
  
  arg1 = (XMLParser *)jarg1; 
  (arg1)->parseReset();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_getColumn(void * jarg1) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  unsigned int result;
  
  arg1 = (XMLParser *)jarg1; 
  result = (unsigned int)((XMLParser const *)arg1)->getColumn();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLParser_getLine(void * jarg1) {
  unsigned int jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  unsigned int result;
  
  arg1 = (XMLParser *)jarg1; 
  result = (unsigned int)((XMLParser const *)arg1)->getLine();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLParser_getErrorLog(void * jarg1) {
  void * jresult ;
  XMLParser *arg1 = (XMLParser *) 0 ;
  XMLErrorLog *result = 0 ;
  
  arg1 = (XMLParser *)jarg1; 
  result = (XMLErrorLog *)(arg1)->getErrorLog();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLParser_setErrorLog(void * jarg1, void * jarg2) {
  XMLParser *arg1 = (XMLParser *) 0 ;
  XMLErrorLog *arg2 = (XMLErrorLog *) 0 ;
  
  arg1 = (XMLParser *)jarg1; 
  arg2 = (XMLErrorLog *)jarg2; 
  (arg1)->setErrorLog(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_XMLTokenizer() {
  void * jresult ;
  XMLTokenizer *result = 0 ;
  
  result = (XMLTokenizer *)new XMLTokenizer();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_XMLTokenizer(void * jarg1) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  delete arg1;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTokenizer_getEncoding(void * jarg1) {
  wchar_t* jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  {
    std::string const &_result_ref = (arg1)->getEncoding();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTokenizer_getVersion(void * jarg1) {
  wchar_t* jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  {
    std::string const &_result_ref = (arg1)->getVersion();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLTokenizer_hasNext(void * jarg1) {
  unsigned int jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  bool result;
  
  arg1 = (XMLTokenizer *)jarg1; 
  result = (bool)((XMLTokenizer const *)arg1)->hasNext();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_XMLTokenizer_isEOF(void * jarg1) {
  unsigned int jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  bool result;
  
  arg1 = (XMLTokenizer *)jarg1; 
  result = (bool)((XMLTokenizer const *)arg1)->isEOF();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLTokenizer_next(void * jarg1) {
  void * jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  XMLToken result;
  
  arg1 = (XMLTokenizer *)jarg1; 
  result = (arg1)->next();
  jresult = new XMLToken((const XMLToken &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_XMLTokenizer_peek(void * jarg1) {
  void * jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  XMLToken *result = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  {
    XMLToken const &_result_ref = (arg1)->peek();
    result = (XMLToken *) &_result_ref;
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_XMLTokenizer_toString(void * jarg1) {
  wchar_t* jresult ;
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  std::string result;
  
  arg1 = (XMLTokenizer *)jarg1; 
  result = (arg1)->toString();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLTokenizer_XML(void * jarg1, wchar_t* jarg2, wchar_t* jarg3) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg_str2 ;
  std::string arg_str3 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    if (!mbstr) return ;
    
    arg_str2.assign(mbstr);
    arg2 = &arg_str2;
    delete[] mbstr;
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg3);
    if (!mbstr) return ;
    
    arg_str3.assign(mbstr);
    arg3 = &arg_str3;
    delete[] mbstr;
  }
  (arg1)->XML((std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLTokenizer_startElement(void * jarg1, void * jarg2) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->startElement((XMLToken const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLTokenizer_endDocument(void * jarg1) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  (arg1)->endDocument();
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLTokenizer_endElement(void * jarg1, void * jarg2) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->endElement((XMLToken const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_XMLTokenizer_characters(void * jarg1, void * jarg2) {
  XMLTokenizer *arg1 = (XMLTokenizer *) 0 ;
  XMLToken *arg2 = 0 ;
  
  arg1 = (XMLTokenizer *)jarg1; 
  arg2 = (XMLToken *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XMLToken const & type is null", 0);
    return ;
  } 
  (arg1)->characters((XMLToken const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_SBMLErrorLog_getError(void * jarg1, long long jarg2) {
  void * jresult ;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  SBMLError *result = 0 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBMLError *)((SBMLErrorLog const *)arg1)->getError(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SBMLErrorLog_getNumFailsWithSeverity(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int result;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (unsigned int)(arg1)->getNumFailsWithSeverity(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLErrorLog() {
  void * jresult ;
  SBMLErrorLog *result = 0 ;
  
  result = (SBMLErrorLog *)new SBMLErrorLog();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBMLErrorLog(void * jarg1) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_0(void * jarg1, long long jarg2, long long jarg3, long long jarg4, wchar_t* jarg5, long long jarg6, long long jarg7, long long jarg8, long long jarg9) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  std::string arg_str5 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  {
    arg8 = (unsigned int)jarg8;  
  }
  {
    arg9 = (unsigned int)jarg9;  
  }
  (arg1)->logError(arg2,arg3,arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_1(void * jarg1, long long jarg2, long long jarg3, long long jarg4, wchar_t* jarg5, long long jarg6, long long jarg7, long long jarg8) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  std::string arg_str5 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  {
    arg8 = (unsigned int)jarg8;  
  }
  (arg1)->logError(arg2,arg3,arg4,(std::string const &)*arg5,arg6,arg7,arg8);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_2(void * jarg1, long long jarg2, long long jarg3, long long jarg4, wchar_t* jarg5, long long jarg6, long long jarg7) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  std::string arg_str5 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  (arg1)->logError(arg2,arg3,arg4,(std::string const &)*arg5,arg6,arg7);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_3(void * jarg1, long long jarg2, long long jarg3, long long jarg4, wchar_t* jarg5, long long jarg6) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 ;
  std::string arg_str5 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  (arg1)->logError(arg2,arg3,arg4,(std::string const &)*arg5,arg6);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_4(void * jarg1, long long jarg2, long long jarg3, long long jarg4, wchar_t* jarg5) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string *arg5 = 0 ;
  std::string arg_str5 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg5);
    if (!mbstr) return ;
    
    arg_str5.assign(mbstr);
    arg5 = &arg_str5;
    delete[] mbstr;
  }
  (arg1)->logError(arg2,arg3,arg4,(std::string const &)*arg5);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_5(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  (arg1)->logError(arg2,arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_6(void * jarg1, long long jarg2, long long jarg3) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  (arg1)->logError(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_7(void * jarg1, long long jarg2) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->logError(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_logError__SWIG_8(void * jarg1) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  (arg1)->logError();
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_add(void * jarg1, void * jarg2) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  SBMLError *arg2 = 0 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  arg2 = (SBMLError *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SBMLError const & type is null", 0);
    return ;
  } 
  (arg1)->add((SBMLError const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_SBMLErrorLog_remove(void * jarg1, long long jarg2) {
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (SBMLErrorLog *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->remove(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_0(long long jarg1, long long jarg2, long long jarg3, wchar_t* jarg4, long long jarg5, long long jarg6, long long jarg7, long long jarg8) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  std::string arg_str4 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  {
    arg8 = (unsigned int)jarg8;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_1(long long jarg1, long long jarg2, long long jarg3, wchar_t* jarg4, long long jarg5, long long jarg6, long long jarg7) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  std::string arg_str4 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,(std::string const &)*arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_2(long long jarg1, long long jarg2, long long jarg3, wchar_t* jarg4, long long jarg5, long long jarg6) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg_str4 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,(std::string const &)*arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_3(long long jarg1, long long jarg2, long long jarg3, wchar_t* jarg4, long long jarg5) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  std::string arg_str4 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,(std::string const &)*arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_4(long long jarg1, long long jarg2, long long jarg3, wchar_t* jarg4) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  std::string arg_str4 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    char*  mbstr = convertUnicodeToUTF8(jarg4);
    if (!mbstr) return 0;
    
    arg_str4.assign(mbstr);
    arg4 = &arg_str4;
    delete[] mbstr;
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_5(long long jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_6(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (SBMLError *)new SBMLError(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_7(long long jarg1) {
  void * jresult ;
  unsigned int arg1 ;
  SBMLError *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (SBMLError *)new SBMLError(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_8() {
  void * jresult ;
  SBMLError *result = 0 ;
  
  result = (SBMLError *)new SBMLError();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SBMLError__SWIG_9(void * jarg1) {
  void * jresult ;
  SBMLError *arg1 = 0 ;
  SBMLError *result = 0 ;
  
  arg1 = (SBMLError *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SBMLError const & type is null", 0);
    return 0;
  } 
  result = (SBMLError *)new SBMLError((SBMLError const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SBMLError(void * jarg1) {
  SBMLError *arg1 = (SBMLError *) 0 ;
  
  arg1 = (SBMLError *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CVTerm__SWIG_0(int jarg1) {
  void * jresult ;
  QualifierType_t arg1 ;
  CVTerm *result = 0 ;
  
  arg1 = (QualifierType_t)jarg1; 
  result = (CVTerm *)new CVTerm(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CVTerm__SWIG_1() {
  void * jresult ;
  CVTerm *result = 0 ;
  
  result = (CVTerm *)new CVTerm();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CVTerm__SWIG_2(void * jarg1) {
  void * jresult ;
  XMLNode arg1 ;
  XMLNode const *argp1 ;
  CVTerm *result = 0 ;
  
  argp1 = (XMLNode *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null XMLNode const", 0);
    return 0;
  }
  arg1 = *argp1; 
  result = (CVTerm *)new CVTerm(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CVTerm(void * jarg1) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  
  arg1 = (CVTerm *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CVTerm__SWIG_3(void * jarg1) {
  void * jresult ;
  CVTerm *arg1 = 0 ;
  CVTerm *result = 0 ;
  
  arg1 = (CVTerm *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CVTerm const & type is null", 0);
    return 0;
  } 
  result = (CVTerm *)new CVTerm((CVTerm const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_CVTerm_clone(void * jarg1) {
  void * jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  CVTerm *result = 0 ;
  
  arg1 = (CVTerm *)jarg1; 
  result = (CVTerm *)((CVTerm const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CVTerm_getQualifierType(void * jarg1) {
  int jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  QualifierType_t result;
  
  arg1 = (CVTerm *)jarg1; 
  result = (QualifierType_t)(arg1)->getQualifierType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CVTerm_getModelQualifierType(void * jarg1) {
  int jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  ModelQualifierType_t result;
  
  arg1 = (CVTerm *)jarg1; 
  result = (ModelQualifierType_t)(arg1)->getModelQualifierType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CVTerm_getBiologicalQualifierType(void * jarg1) {
  int jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  BiolQualifierType_t result;
  
  arg1 = (CVTerm *)jarg1; 
  result = (BiolQualifierType_t)(arg1)->getBiologicalQualifierType();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_CVTerm_getResources__SWIG_0(void * jarg1) {
  void * jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  XMLAttributes *result = 0 ;
  
  arg1 = (CVTerm *)jarg1; 
  result = (XMLAttributes *)(arg1)->getResources();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CVTerm_getNumResources(void * jarg1) {
  unsigned int jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int result;
  
  arg1 = (CVTerm *)jarg1; 
  result = (unsigned int)(arg1)->getNumResources();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_CVTerm_getResourceURI(void * jarg1, long long jarg2) {
  wchar_t* jresult ;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  std::string result;
  
  arg1 = (CVTerm *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (arg1)->getResourceURI(arg2);
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CVTerm_setQualifierType(void * jarg1, int jarg2) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  QualifierType_t arg2 ;
  
  arg1 = (CVTerm *)jarg1; 
  arg2 = (QualifierType_t)jarg2; 
  (arg1)->setQualifierType(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CVTerm_setModelQualifierType(void * jarg1, int jarg2) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  ModelQualifierType_t arg2 ;
  
  arg1 = (CVTerm *)jarg1; 
  arg2 = (ModelQualifierType_t)jarg2; 
  (arg1)->setModelQualifierType(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CVTerm_setBiologicalQualifierType(void * jarg1, int jarg2) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  BiolQualifierType_t arg2 ;
  
  arg1 = (CVTerm *)jarg1; 
  arg2 = (BiolQualifierType_t)jarg2; 
  (arg1)->setBiologicalQualifierType(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CVTerm_addResource(void * jarg1, wchar_t* jarg2) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string arg2 ;
  
  arg1 = (CVTerm *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->addResource(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CVTerm_removeResource(void * jarg1, wchar_t* jarg2) {
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string arg2 ;
  
  arg1 = (CVTerm *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->removeResource(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_0(long long jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6, long long jarg7, long long jarg8, long long jarg9) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  {
    arg8 = (unsigned int)jarg8;  
  }
  {
    arg9 = (unsigned int)jarg9;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_1(long long jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6, long long jarg7, long long jarg8) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  {
    arg8 = (unsigned int)jarg8;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_2(long long jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6, long long jarg7) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  {
    arg7 = (unsigned int)jarg7;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_3(long long jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  {
    arg6 = (unsigned int)jarg6;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_4(long long jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  {
    arg5 = (unsigned int)jarg5;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_5(long long jarg1, long long jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  {
    arg4 = (unsigned int)jarg4;  
  }
  result = (Date *)new Date(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_6(long long jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  {
    arg3 = (unsigned int)jarg3;  
  }
  result = (Date *)new Date(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_7(long long jarg1, long long jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Date *)new Date(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_8(long long jarg1) {
  void * jresult ;
  unsigned int arg1 ;
  Date *result = 0 ;
  
  {
    arg1 = (unsigned int)jarg1;  
  }
  result = (Date *)new Date(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_9() {
  void * jresult ;
  Date *result = 0 ;
  
  result = (Date *)new Date();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_10(wchar_t* jarg1) {
  void * jresult ;
  std::string arg1 ;
  Date *result = 0 ;
  
  {
    char*  mbstr = convertUnicodeToUTF8(jarg1);
    (&arg1)->assign(mbstr);
    delete[] mbstr;
  }
  result = (Date *)new Date(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Date(void * jarg1) {
  Date *arg1 = (Date *) 0 ;
  
  arg1 = (Date *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Date__SWIG_11(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & type is null", 0);
    return 0;
  } 
  result = (Date *)new Date((Date const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Date_clone(void * jarg1) {
  void * jresult ;
  Date *arg1 = (Date *) 0 ;
  Date *result = 0 ;
  
  arg1 = (Date *)jarg1; 
  result = (Date *)((Date const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getYear(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getYear();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getMonth(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getMonth();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getDay(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getDay();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getHour(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getHour();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getMinute(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getMinute();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getSecond(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getSecond();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getSignOffset(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getSignOffset();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getHoursOffset(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getHoursOffset();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Date_getMinutesOffset(void * jarg1) {
  unsigned int jresult ;
  Date *arg1 = (Date *) 0 ;
  unsigned int result;
  
  arg1 = (Date *)jarg1; 
  result = (unsigned int)(arg1)->getMinutesOffset();
  jresult = result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_Date_getDateAsString(void * jarg1) {
  wchar_t* jresult ;
  Date *arg1 = (Date *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (Date *)jarg1; 
  {
    std::string const &_result_ref = (arg1)->getDateAsString();
    result = (std::string *) &_result_ref;
  }
  {
    jresult = convertUTF8ToUnicode((result)->c_str());
    wchar_t* unistr = convertUTF8ToUnicode((result)->c_str());
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setYear(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setYear(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setMonth(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setMonth(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setDay(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setDay(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setHour(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setHour(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setMinute(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setMinute(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setSecond(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setSecond(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setSignOffset(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setSignOffset(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setHoursOffset(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setHoursOffset(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setMinutesOffset(void * jarg1, long long jarg2) {
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  (arg1)->setMinutesOffset(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Date_setDateAsString(void * jarg1, wchar_t* jarg2) {
  Date *arg1 = (Date *) 0 ;
  std::string arg2 ;
  
  arg1 = (Date *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setDateAsString(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModelCreator__SWIG_0() {
  void * jresult ;
  ModelCreator *result = 0 ;
  
  result = (ModelCreator *)new ModelCreator();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModelCreator__SWIG_1(void * jarg1) {
  void * jresult ;
  XMLNode arg1 ;
  XMLNode const *argp1 ;
  ModelCreator *result = 0 ;
  
  argp1 = (XMLNode *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null XMLNode const", 0);
    return 0;
  }
  arg1 = *argp1; 
  result = (ModelCreator *)new ModelCreator(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ModelCreator(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModelCreator__SWIG_2(void * jarg1) {
  void * jresult ;
  ModelCreator *arg1 = 0 ;
  ModelCreator *result = 0 ;
  
  arg1 = (ModelCreator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ModelCreator const & type is null", 0);
    return 0;
  } 
  result = (ModelCreator *)new ModelCreator((ModelCreator const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelCreator_clone(void * jarg1) {
  void * jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  ModelCreator *result = 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (ModelCreator *)((ModelCreator const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModelCreator_getFamilyName(void * jarg1) {
  wchar_t* jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (arg1)->getFamilyName();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModelCreator_getGivenName(void * jarg1) {
  wchar_t* jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (arg1)->getGivenName();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModelCreator_getEmail(void * jarg1) {
  wchar_t* jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (arg1)->getEmail();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModelCreator_getOrganization(void * jarg1) {
  wchar_t* jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (arg1)->getOrganization();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT wchar_t* SWIGSTDCALL CSharp_ModelCreator_getOrganisation(void * jarg1) {
  wchar_t* jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (arg1)->getOrganisation();
  {
    jresult = convertUTF8ToUnicode( (&result)->c_str() );
    wchar_t* unistr = convertUTF8ToUnicode( (&result)->c_str() );
    jresult = (wchar_t*) SWIG_csharp_wstring_callback((const wchar_t*)unistr);
    delete[] unistr;
  }
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelCreator_isSetFamilyName(void * jarg1) {
  unsigned int jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (bool)(arg1)->isSetFamilyName();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelCreator_isSetGivenName(void * jarg1) {
  unsigned int jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (bool)(arg1)->isSetGivenName();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelCreator_isSetEmail(void * jarg1) {
  unsigned int jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (bool)(arg1)->isSetEmail();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelCreator_isSetOrganization(void * jarg1) {
  unsigned int jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (bool)(arg1)->isSetOrganization();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelCreator_isSetOrganisation(void * jarg1) {
  unsigned int jresult ;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool result;
  
  arg1 = (ModelCreator *)jarg1; 
  result = (bool)(arg1)->isSetOrganisation();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_setFamilyName(void * jarg1, wchar_t* jarg2) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string arg2 ;
  
  arg1 = (ModelCreator *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setFamilyName(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_setGivenName(void * jarg1, wchar_t* jarg2) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string arg2 ;
  
  arg1 = (ModelCreator *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setGivenName(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_setEmail(void * jarg1, wchar_t* jarg2) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string arg2 ;
  
  arg1 = (ModelCreator *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setEmail(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_setOrganization(void * jarg1, wchar_t* jarg2) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string arg2 ;
  
  arg1 = (ModelCreator *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setOrganization(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_setOrganisation(void * jarg1, wchar_t* jarg2) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string arg2 ;
  
  arg1 = (ModelCreator *)jarg1; 
  {
    char*  mbstr = convertUnicodeToUTF8(jarg2);
    (&arg2)->assign(mbstr);
    delete[] mbstr;
  }
  (arg1)->setOrganisation(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_unsetFamilyName(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  (arg1)->unsetFamilyName();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_unsetGivenName(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  (arg1)->unsetGivenName();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_unsetEmail(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  (arg1)->unsetEmail();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_unsetOrganization(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  (arg1)->unsetOrganization();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelCreator_unsetOrganisation(void * jarg1) {
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  
  arg1 = (ModelCreator *)jarg1; 
  (arg1)->unsetOrganisation();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModelHistory__SWIG_0() {
  void * jresult ;
  ModelHistory *result = 0 ;
  
  result = (ModelHistory *)new ModelHistory();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ModelHistory(void * jarg1) {
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ModelHistory__SWIG_1(void * jarg1) {
  void * jresult ;
  ModelHistory *arg1 = 0 ;
  ModelHistory *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ModelHistory const & type is null", 0);
    return 0;
  } 
  result = (ModelHistory *)new ModelHistory((ModelHistory const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelHistory_clone(void * jarg1) {
  void * jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  ModelHistory *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (ModelHistory *)((ModelHistory const *)arg1)->clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelHistory_getCreatedDate(void * jarg1) {
  void * jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (Date *)(arg1)->getCreatedDate();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelHistory_getModifiedDate__SWIG_0(void * jarg1) {
  void * jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (Date *)(arg1)->getModifiedDate();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelHistory_isSetCreatedDate(void * jarg1) {
  unsigned int jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  bool result;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (bool)(arg1)->isSetCreatedDate();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelHistory_isSetModifiedDate(void * jarg1) {
  unsigned int jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  bool result;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (bool)(arg1)->isSetModifiedDate();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelHistory_setCreatedDate(void * jarg1, void * jarg2) {
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  arg2 = (Date *)jarg2; 
  (arg1)->setCreatedDate(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelHistory_setModifiedDate(void * jarg1, void * jarg2) {
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  arg2 = (Date *)jarg2; 
  (arg1)->setModifiedDate(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelHistory_addModifiedDate(void * jarg1, void * jarg2) {
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  arg2 = (Date *)jarg2; 
  (arg1)->addModifiedDate(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelHistory_getModifiedDate__SWIG_1(void * jarg1, long long jarg2) {
  void * jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int arg2 ;
  Date *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (Date *)(arg1)->getModifiedDate(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelHistory_getNumModifiedDates(void * jarg1) {
  unsigned int jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int result;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (unsigned int)(arg1)->getNumModifiedDates();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ModelHistory_addCreator(void * jarg1, void * jarg2) {
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  arg2 = (ModelCreator *)jarg2; 
  (arg1)->addCreator(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ModelHistory_getCreator(void * jarg1, long long jarg2) {
  void * jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int arg2 ;
  ModelCreator *result = 0 ;
  
  arg1 = (ModelHistory *)jarg1; 
  {
    arg2 = (unsigned int)jarg2;  
  }
  result = (ModelCreator *)(arg1)->getCreator(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ModelHistory_getNumCreators(void * jarg1) {
  unsigned int jresult ;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int result;
  
  arg1 = (ModelHistory *)jarg1; 
  result = (unsigned int)(arg1)->getNumCreators();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_parseRDFAnnotation(void * jarg1) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  ModelHistory *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  result = (ModelHistory *)RDFAnnotationParser::parseRDFAnnotation((XMLNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_createAnnotation() {
  void * jresult ;
  XMLNode *result = 0 ;
  
  result = (XMLNode *)RDFAnnotationParser::createAnnotation();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_createRDFAnnotation() {
  void * jresult ;
  XMLNode *result = 0 ;
  
  result = (XMLNode *)RDFAnnotationParser::createRDFAnnotation();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_deleteRDFAnnotation(void * jarg1) {
  void * jresult ;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (XMLNode *)jarg1; 
  result = (XMLNode *)RDFAnnotationParser::deleteRDFAnnotation((XMLNode const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_createRDFDescription(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNode *)RDFAnnotationParser::createRDFDescription((SBase const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_createCVTerms(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNode *)RDFAnnotationParser::createCVTerms((SBase const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_parseCVTerms(void * jarg1) {
  void * jresult ;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (SBase *)jarg1; 
  result = (XMLNode *)RDFAnnotationParser::parseCVTerms((SBase const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RDFAnnotationParser_parseModelHistory(void * jarg1) {
  void * jresult ;
  Model *arg1 = (Model *) 0 ;
  XMLNode *result = 0 ;
  
  arg1 = (Model *)jarg1; 
  result = (XMLNode *)RDFAnnotationParser::parseModelHistory((Model const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RDFAnnotationParser() {
  void * jresult ;
  RDFAnnotationParser *result = 0 ;
  
  result = (RDFAnnotationParser *)new RDFAnnotationParser();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_RDFAnnotationParser(void * jarg1) {
  RDFAnnotationParser *arg1 = (RDFAnnotationParser *) 0 ;
  
  arg1 = (RDFAnnotationParser *)jarg1; 
  delete arg1;
}


SWIGEXPORT OStream * SWIGSTDCALL CSharp_OFStreamUpcast(OFStream *objectRef) {
    return (OStream *)objectRef;
}

SWIGEXPORT OStream * SWIGSTDCALL CSharp_OStringStreamUpcast(OStringStream *objectRef) {
    return (OStream *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_ListOfUpcast(ListOf *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_ModelUpcast(Model *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_SBMLDocumentUpcast(SBMLDocument *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_FunctionDefinitionUpcast(FunctionDefinition *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfFunctionDefinitionsUpcast(ListOfFunctionDefinitions *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_UnitUpcast(Unit *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfUnitsUpcast(ListOfUnits *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_UnitDefinitionUpcast(UnitDefinition *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfUnitDefinitionsUpcast(ListOfUnitDefinitions *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_CompartmentTypeUpcast(CompartmentType *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfCompartmentTypesUpcast(ListOfCompartmentTypes *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_SpeciesTypeUpcast(SpeciesType *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfSpeciesTypesUpcast(ListOfSpeciesTypes *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_CompartmentUpcast(Compartment *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfCompartmentsUpcast(ListOfCompartments *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_SpeciesUpcast(Species *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfSpeciesUpcast(ListOfSpecies *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_ParameterUpcast(Parameter *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfParametersUpcast(ListOfParameters *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_InitialAssignmentUpcast(InitialAssignment *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfInitialAssignmentsUpcast(ListOfInitialAssignments *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_RuleUpcast(Rule *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT Rule * SWIGSTDCALL CSharp_AlgebraicRuleUpcast(AlgebraicRule *objectRef) {
    return (Rule *)objectRef;
}

SWIGEXPORT Rule * SWIGSTDCALL CSharp_AssignmentRuleUpcast(AssignmentRule *objectRef) {
    return (Rule *)objectRef;
}

SWIGEXPORT Rule * SWIGSTDCALL CSharp_RateRuleUpcast(RateRule *objectRef) {
    return (Rule *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfRulesUpcast(ListOfRules *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_ConstraintUpcast(Constraint *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfConstraintsUpcast(ListOfConstraints *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_ReactionUpcast(Reaction *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfReactionsUpcast(ListOfReactions *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_KineticLawUpcast(KineticLaw *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_SimpleSpeciesReferenceUpcast(SimpleSpeciesReference *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SimpleSpeciesReference * SWIGSTDCALL CSharp_SpeciesReferenceUpcast(SpeciesReference *objectRef) {
    return (SimpleSpeciesReference *)objectRef;
}

SWIGEXPORT SimpleSpeciesReference * SWIGSTDCALL CSharp_ModifierSpeciesReferenceUpcast(ModifierSpeciesReference *objectRef) {
    return (SimpleSpeciesReference *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfSpeciesReferencesUpcast(ListOfSpeciesReferences *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_EventUpcast(Event *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfEventsUpcast(ListOfEvents *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_EventAssignmentUpcast(EventAssignment *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT ListOf * SWIGSTDCALL CSharp_ListOfEventAssignmentsUpcast(ListOfEventAssignments *objectRef) {
    return (ListOf *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_TriggerUpcast(Trigger *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_DelayUpcast(Delay *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT SBase * SWIGSTDCALL CSharp_StoichiometryMathUpcast(StoichiometryMath *objectRef) {
    return (SBase *)objectRef;
}

SWIGEXPORT XMLToken * SWIGSTDCALL CSharp_XMLNodeUpcast(XMLNode *objectRef) {
    return (XMLToken *)objectRef;
}

SWIGEXPORT XMLHandler * SWIGSTDCALL CSharp_XMLTokenizerUpcast(XMLTokenizer *objectRef) {
    return (XMLHandler *)objectRef;
}

SWIGEXPORT XMLErrorLog * SWIGSTDCALL CSharp_SBMLErrorLogUpcast(SBMLErrorLog *objectRef) {
    return (XMLErrorLog *)objectRef;
}

SWIGEXPORT XMLError * SWIGSTDCALL CSharp_SBMLErrorUpcast(SBMLError *objectRef) {
    return (XMLError *)objectRef;
}

#ifdef __cplusplus
}
#endif

