/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.1
 * 
 * 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_openbabelcsharp(
                                                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_openbabelcsharp(
                                                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_openbabelcsharp(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


typedef double CDoubleArray;

SWIGINTERN CDoubleArray *new_CDoubleArray(int nelements){
  return new double[nelements];
}
SWIGINTERN void delete_CDoubleArray(CDoubleArray *self){
  delete [] self;
}
SWIGINTERN double CDoubleArray_getitem(CDoubleArray *self,int index){
  return self[index];
}
SWIGINTERN void CDoubleArray_setitem(CDoubleArray *self,int index,double value){
  self[index] = value;
}
SWIGINTERN double *CDoubleArray_cast(CDoubleArray *self){
  return self;
}
SWIGINTERN CDoubleArray *CDoubleArray_frompointer(double *t){
  return (CDoubleArray *) t;
}

typedef int CIntArray;

SWIGINTERN CIntArray *new_CIntArray(int nelements){
  return new int[nelements];
}
SWIGINTERN void delete_CIntArray(CIntArray *self){
  delete [] self;
}
SWIGINTERN int CIntArray_getitem(CIntArray *self,int index){
  return self[index];
}
SWIGINTERN void CIntArray_setitem(CIntArray *self,int index,int value){
  self[index] = value;
}
SWIGINTERN int *CIntArray_cast(CIntArray *self){
  return self;
}
SWIGINTERN CIntArray *CIntArray_frompointer(int *t){
  return (CIntArray *) t;
}

typedef unsigned char CByteArray;

SWIGINTERN CByteArray *new_CByteArray(int nelements){
  return new unsigned char[nelements];
}
SWIGINTERN void delete_CByteArray(CByteArray *self){
  delete [] self;
}
SWIGINTERN unsigned char CByteArray_getitem(CByteArray *self,int index){
  return self[index];
}
SWIGINTERN void CByteArray_setitem(CByteArray *self,int index,unsigned char value){
  self[index] = value;
}
SWIGINTERN unsigned char *CByteArray_cast(CByteArray *self){
  return self;
}
SWIGINTERN CByteArray *CByteArray_frompointer(unsigned char *t){
  return (CByteArray *) t;
}

typedef unsigned int CUIntArray;

SWIGINTERN CUIntArray *new_CUIntArray(int nelements){
  return new unsigned int[nelements];
}
SWIGINTERN void delete_CUIntArray(CUIntArray *self){
  delete [] self;
}
SWIGINTERN unsigned int CUIntArray_getitem(CUIntArray *self,int index){
  return self[index];
}
SWIGINTERN void CUIntArray_setitem(CUIntArray *self,int index,unsigned int value){
  self[index] = value;
}
SWIGINTERN unsigned int *CUIntArray_cast(CUIntArray *self){
  return self;
}
SWIGINTERN CUIntArray *CUIntArray_frompointer(unsigned int *t){
  return (CUIntArray *) t;
}

// used to set import/export for Cygwin DLLs
#ifdef WIN32
#define USING_OBDLL
#endif

#include <openbabel/obutil.h>
#include <openbabel/rand.h>
#include <openbabel/math/vector3.h>
#include <openbabel/math/matrix3x3.h>
#include <openbabel/math/transform3d.h>
#include <openbabel/generic.h>

#include <openbabel/base.h>
#include <openbabel/mol.h>
#include <openbabel/atom.h>
#include <openbabel/bond.h>
#include <openbabel/residue.h>
#include <openbabel/internalcoord.h>

#include <openbabel/ring.h>
#include <openbabel/obconversion.h>
#include <openbabel/oberror.h>
#include <openbabel/plugin.h>
#include <openbabel/fingerprint.h>
#include <openbabel/descriptor.h>
#include <openbabel/format.h>

#include <openbabel/forcefield.h>
#include <openbabel/builder.h>
#include <openbabel/op.h>

#include <openbabel/bitvec.h>
#include <openbabel/data.h>
#include <openbabel/parsmart.h>
#include <openbabel/alias.h>
#include <openbabel/atomclass.h>

#include <openbabel/kinetics.h>
//OBReaction can't be mapped properly
//until shared_ptr is mapped
//#include <openbabel/reaction.h>
#include <openbabel/rotor.h>
#include <openbabel/rotamer.h>



#include <string>


#include <stdexcept>


#include <vector>
#include <algorithm>
#include <stdexcept>

SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(int capacity){
        std::vector< int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__getitem(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self,int index,int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self,int index,int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__Repeat(int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< int >(count, value);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self,int const &value){
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< int > > *new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< int > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< int > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< int > std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< int > >::const_reference std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(std::vector< std::vector< int > > *self,int index,std::vector< int > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(std::vector< std::vector< int > > *self,std::vector< std::vector< int > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< int > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(std::vector< std::vector< int > > *self,int index,std::vector< int > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat(std::vector< int > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< int > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
        std::vector< unsigned int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< unsigned int >::const_reference std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned int >(count, value);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< unsigned int > > *new_std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< unsigned int > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< unsigned int > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< unsigned int > std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__getitemcopy(std::vector< std::vector< unsigned int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< unsigned int > >::const_reference std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__getitem(std::vector< std::vector< unsigned int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__setitem(std::vector< std::vector< unsigned int > > *self,int index,std::vector< unsigned int > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__AddRange(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< unsigned int > > *std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__GetRange(std::vector< std::vector< unsigned int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< unsigned int > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Insert(std::vector< std::vector< unsigned int > > *self,int index,std::vector< unsigned int > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__InsertRange(std::vector< std::vector< unsigned int > > *self,int index,std::vector< std::vector< unsigned int > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__RemoveAt(std::vector< std::vector< unsigned int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__RemoveRange(std::vector< std::vector< unsigned int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< unsigned int > > *std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Repeat(std::vector< unsigned int > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< unsigned int > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< unsigned int > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< unsigned int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__SetRange(std::vector< std::vector< unsigned int > > *self,int index,std::vector< std::vector< unsigned int > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< unsigned short > *new_std_vector_Sl_unsigned_SS_short_Sg___SWIG_2(int capacity){
        std::vector< unsigned short >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned short >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned short std_vector_Sl_unsigned_SS_short_Sg__getitemcopy(std::vector< unsigned short > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< unsigned short >::const_reference std_vector_Sl_unsigned_SS_short_Sg__getitem(std::vector< unsigned short > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__setitem(std::vector< unsigned short > *self,int index,unsigned short const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__AddRange(std::vector< unsigned short > *self,std::vector< unsigned short > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned short > *std_vector_Sl_unsigned_SS_short_Sg__GetRange(std::vector< unsigned short > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned short >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__Insert(std::vector< unsigned short > *self,int index,unsigned short const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__InsertRange(std::vector< unsigned short > *self,int index,std::vector< unsigned short > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__RemoveAt(std::vector< unsigned short > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__RemoveRange(std::vector< unsigned short > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned short > *std_vector_Sl_unsigned_SS_short_Sg__Repeat(unsigned short const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned short >(count, value);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__Reverse__SWIG_0(std::vector< unsigned short > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__Reverse__SWIG_1(std::vector< unsigned short > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__SetRange(std::vector< unsigned short > *self,int index,std::vector< unsigned short > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_short_Sg__Contains(std::vector< unsigned short > *self,unsigned short const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_short_Sg__IndexOf(std::vector< unsigned short > *self,unsigned short const &value){
        int index = -1;
        std::vector< unsigned short >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_unsigned_SS_short_Sg__LastIndexOf(std::vector< unsigned short > *self,unsigned short const &value){
        int index = -1;
        std::vector< unsigned short >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_unsigned_SS_short_Sg__Remove(std::vector< unsigned short > *self,unsigned short const &value){
        std::vector< unsigned short >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(int capacity){
        std::vector< double >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< double >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__getitem(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self,int index,double const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self,std::vector< double > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__GetRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< double >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self,int index,double const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__Repeat(double const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< double >(count, value);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self,double const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self,double const &value){
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< double > > *new_std_vector_Sl_std_vector_Sl_double_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< double > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< double > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< double > std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitemcopy(std::vector< std::vector< double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< double > >::const_reference std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitem(std::vector< std::vector< double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__setitem(std::vector< std::vector< double > > *self,int index,std::vector< double > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__AddRange(std::vector< std::vector< double > > *self,std::vector< std::vector< double > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< double > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__GetRange(std::vector< std::vector< double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< double > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Insert(std::vector< std::vector< double > > *self,int index,std::vector< double > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__InsertRange(std::vector< std::vector< double > > *self,int index,std::vector< std::vector< double > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__RemoveAt(std::vector< std::vector< double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__RemoveRange(std::vector< std::vector< double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< double > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__Repeat(std::vector< double > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< double > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< double > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< double > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__SetRange(std::vector< std::vector< double > > *self,int index,std::vector< std::vector< double > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(int capacity){
        std::vector< std::string >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::string >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::string std_vector_Sl_std_string_Sg__getitemcopy(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__getitem(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__setitem(std::vector< std::string > *self,int index,std::string const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__AddRange(std::vector< std::string > *self,std::vector< std::string > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__GetRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::string >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Insert(std::vector< std::string > *self,int index,std::string const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__InsertRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveAt(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__Repeat(std::string const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::string >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_0(std::vector< std::string > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_1(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__SetRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Contains(std::vector< std::string > *self,std::string const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__IndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__LastIndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Remove(std::vector< std::string > *self,std::string const &value){
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::vector3 > *new_std_vector_Sl_OpenBabel_vector3_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::vector3 >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::vector3 >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::vector3 std_vector_Sl_OpenBabel_vector3_Sg__getitemcopy(std::vector< OpenBabel::vector3 > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::vector3 >::const_reference std_vector_Sl_OpenBabel_vector3_Sg__getitem(std::vector< OpenBabel::vector3 > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__setitem(std::vector< OpenBabel::vector3 > *self,int index,OpenBabel::vector3 const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__AddRange(std::vector< OpenBabel::vector3 > *self,std::vector< OpenBabel::vector3 > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::vector3 > *std_vector_Sl_OpenBabel_vector3_Sg__GetRange(std::vector< OpenBabel::vector3 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::vector3 >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__Insert(std::vector< OpenBabel::vector3 > *self,int index,OpenBabel::vector3 const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__InsertRange(std::vector< OpenBabel::vector3 > *self,int index,std::vector< OpenBabel::vector3 > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__RemoveAt(std::vector< OpenBabel::vector3 > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__RemoveRange(std::vector< OpenBabel::vector3 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::vector3 > *std_vector_Sl_OpenBabel_vector3_Sg__Repeat(OpenBabel::vector3 const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::vector3 >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__Reverse__SWIG_0(std::vector< OpenBabel::vector3 > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__Reverse__SWIG_1(std::vector< OpenBabel::vector3 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_vector3_Sg__SetRange(std::vector< OpenBabel::vector3 > *self,int index,std::vector< OpenBabel::vector3 > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< std::vector< OpenBabel::vector3 > > *new_std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< OpenBabel::vector3 > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< OpenBabel::vector3 > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< OpenBabel::vector3 > std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__getitemcopy(std::vector< std::vector< OpenBabel::vector3 > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< OpenBabel::vector3 > >::const_reference std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__getitem(std::vector< std::vector< OpenBabel::vector3 > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__setitem(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,std::vector< OpenBabel::vector3 > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__AddRange(std::vector< std::vector< OpenBabel::vector3 > > *self,std::vector< std::vector< OpenBabel::vector3 > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< OpenBabel::vector3 > > *std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__GetRange(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< OpenBabel::vector3 > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Insert(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,std::vector< OpenBabel::vector3 > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__InsertRange(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,std::vector< std::vector< OpenBabel::vector3 > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__RemoveAt(std::vector< std::vector< OpenBabel::vector3 > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__RemoveRange(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< OpenBabel::vector3 > > *std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Repeat(std::vector< OpenBabel::vector3 > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< OpenBabel::vector3 > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< OpenBabel::vector3 > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__SetRange(std::vector< std::vector< OpenBabel::vector3 > > *self,int index,std::vector< std::vector< OpenBabel::vector3 > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBExternalBond > *new_std_vector_Sl_OpenBabel_OBExternalBond_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBExternalBond >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBExternalBond >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBExternalBond std_vector_Sl_OpenBabel_OBExternalBond_Sg__getitemcopy(std::vector< OpenBabel::OBExternalBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBExternalBond >::const_reference std_vector_Sl_OpenBabel_OBExternalBond_Sg__getitem(std::vector< OpenBabel::OBExternalBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__setitem(std::vector< OpenBabel::OBExternalBond > *self,int index,OpenBabel::OBExternalBond const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__AddRange(std::vector< OpenBabel::OBExternalBond > *self,std::vector< OpenBabel::OBExternalBond > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBExternalBond > *std_vector_Sl_OpenBabel_OBExternalBond_Sg__GetRange(std::vector< OpenBabel::OBExternalBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBExternalBond >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__Insert(std::vector< OpenBabel::OBExternalBond > *self,int index,OpenBabel::OBExternalBond const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__InsertRange(std::vector< OpenBabel::OBExternalBond > *self,int index,std::vector< OpenBabel::OBExternalBond > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__RemoveAt(std::vector< OpenBabel::OBExternalBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__RemoveRange(std::vector< OpenBabel::OBExternalBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBExternalBond > *std_vector_Sl_OpenBabel_OBExternalBond_Sg__Repeat(OpenBabel::OBExternalBond const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBExternalBond >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBExternalBond > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBExternalBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBExternalBond_Sg__SetRange(std::vector< OpenBabel::OBExternalBond > *self,int index,std::vector< OpenBabel::OBExternalBond > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBMol > *new_std_vector_Sl_OpenBabel_OBMol_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBMol >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBMol >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBMol std_vector_Sl_OpenBabel_OBMol_Sg__getitemcopy(std::vector< OpenBabel::OBMol > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBMol >::const_reference std_vector_Sl_OpenBabel_OBMol_Sg__getitem(std::vector< OpenBabel::OBMol > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__setitem(std::vector< OpenBabel::OBMol > *self,int index,OpenBabel::OBMol const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__AddRange(std::vector< OpenBabel::OBMol > *self,std::vector< OpenBabel::OBMol > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBMol > *std_vector_Sl_OpenBabel_OBMol_Sg__GetRange(std::vector< OpenBabel::OBMol > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBMol >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__Insert(std::vector< OpenBabel::OBMol > *self,int index,OpenBabel::OBMol const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__InsertRange(std::vector< OpenBabel::OBMol > *self,int index,std::vector< OpenBabel::OBMol > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__RemoveAt(std::vector< OpenBabel::OBMol > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__RemoveRange(std::vector< OpenBabel::OBMol > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBMol > *std_vector_Sl_OpenBabel_OBMol_Sg__Repeat(OpenBabel::OBMol const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBMol >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBMol > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBMol > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBMol_Sg__SetRange(std::vector< OpenBabel::OBMol > *self,int index,std::vector< OpenBabel::OBMol > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBBond > *new_std_vector_Sl_OpenBabel_OBBond_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBBond >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBBond >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBBond std_vector_Sl_OpenBabel_OBBond_Sg__getitemcopy(std::vector< OpenBabel::OBBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBBond >::const_reference std_vector_Sl_OpenBabel_OBBond_Sg__getitem(std::vector< OpenBabel::OBBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__setitem(std::vector< OpenBabel::OBBond > *self,int index,OpenBabel::OBBond const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__AddRange(std::vector< OpenBabel::OBBond > *self,std::vector< OpenBabel::OBBond > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBBond > *std_vector_Sl_OpenBabel_OBBond_Sg__GetRange(std::vector< OpenBabel::OBBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBBond >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__Insert(std::vector< OpenBabel::OBBond > *self,int index,OpenBabel::OBBond const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__InsertRange(std::vector< OpenBabel::OBBond > *self,int index,std::vector< OpenBabel::OBBond > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__RemoveAt(std::vector< OpenBabel::OBBond > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__RemoveRange(std::vector< OpenBabel::OBBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBBond > *std_vector_Sl_OpenBabel_OBBond_Sg__Repeat(OpenBabel::OBBond const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBBond >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBBond > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBBond > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sg__SetRange(std::vector< OpenBabel::OBBond > *self,int index,std::vector< OpenBabel::OBBond > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBResidue > *new_std_vector_Sl_OpenBabel_OBResidue_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBResidue >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBResidue >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBResidue std_vector_Sl_OpenBabel_OBResidue_Sg__getitemcopy(std::vector< OpenBabel::OBResidue > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBResidue >::const_reference std_vector_Sl_OpenBabel_OBResidue_Sg__getitem(std::vector< OpenBabel::OBResidue > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__setitem(std::vector< OpenBabel::OBResidue > *self,int index,OpenBabel::OBResidue const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__AddRange(std::vector< OpenBabel::OBResidue > *self,std::vector< OpenBabel::OBResidue > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBResidue > *std_vector_Sl_OpenBabel_OBResidue_Sg__GetRange(std::vector< OpenBabel::OBResidue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBResidue >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__Insert(std::vector< OpenBabel::OBResidue > *self,int index,OpenBabel::OBResidue const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__InsertRange(std::vector< OpenBabel::OBResidue > *self,int index,std::vector< OpenBabel::OBResidue > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__RemoveAt(std::vector< OpenBabel::OBResidue > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__RemoveRange(std::vector< OpenBabel::OBResidue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBResidue > *std_vector_Sl_OpenBabel_OBResidue_Sg__Repeat(OpenBabel::OBResidue const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBResidue >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBResidue > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBResidue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBResidue_Sg__SetRange(std::vector< OpenBabel::OBResidue > *self,int index,std::vector< OpenBabel::OBResidue > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBRing > *new_std_vector_Sl_OpenBabel_OBRing_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBRing >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBRing >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBRing std_vector_Sl_OpenBabel_OBRing_Sg__getitemcopy(std::vector< OpenBabel::OBRing > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBRing >::const_reference std_vector_Sl_OpenBabel_OBRing_Sg__getitem(std::vector< OpenBabel::OBRing > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__setitem(std::vector< OpenBabel::OBRing > *self,int index,OpenBabel::OBRing const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__AddRange(std::vector< OpenBabel::OBRing > *self,std::vector< OpenBabel::OBRing > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBRing > *std_vector_Sl_OpenBabel_OBRing_Sg__GetRange(std::vector< OpenBabel::OBRing > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBRing >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__Insert(std::vector< OpenBabel::OBRing > *self,int index,OpenBabel::OBRing const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__InsertRange(std::vector< OpenBabel::OBRing > *self,int index,std::vector< OpenBabel::OBRing > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__RemoveAt(std::vector< OpenBabel::OBRing > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__RemoveRange(std::vector< OpenBabel::OBRing > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBRing > *std_vector_Sl_OpenBabel_OBRing_Sg__Repeat(OpenBabel::OBRing const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBRing >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBRing > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBRing > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sg__SetRange(std::vector< OpenBabel::OBRing > *self,int index,std::vector< OpenBabel::OBRing > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBTorsion > *new_std_vector_Sl_OpenBabel_OBTorsion_Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBTorsion >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBTorsion >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBTorsion std_vector_Sl_OpenBabel_OBTorsion_Sg__getitemcopy(std::vector< OpenBabel::OBTorsion > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBTorsion >::const_reference std_vector_Sl_OpenBabel_OBTorsion_Sg__getitem(std::vector< OpenBabel::OBTorsion > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__setitem(std::vector< OpenBabel::OBTorsion > *self,int index,OpenBabel::OBTorsion const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__AddRange(std::vector< OpenBabel::OBTorsion > *self,std::vector< OpenBabel::OBTorsion > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBTorsion > *std_vector_Sl_OpenBabel_OBTorsion_Sg__GetRange(std::vector< OpenBabel::OBTorsion > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBTorsion >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__Insert(std::vector< OpenBabel::OBTorsion > *self,int index,OpenBabel::OBTorsion const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__InsertRange(std::vector< OpenBabel::OBTorsion > *self,int index,std::vector< OpenBabel::OBTorsion > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__RemoveAt(std::vector< OpenBabel::OBTorsion > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__RemoveRange(std::vector< OpenBabel::OBTorsion > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBTorsion > *std_vector_Sl_OpenBabel_OBTorsion_Sg__Repeat(OpenBabel::OBTorsion const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBTorsion >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBTorsion > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBTorsion > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBTorsion_Sg__SetRange(std::vector< OpenBabel::OBTorsion > *self,int index,std::vector< OpenBabel::OBTorsion > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< OpenBabel::OBRing * > *new_std_vector_Sl_OpenBabel_OBRing_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBRing * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBRing * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBRing *std_vector_Sl_OpenBabel_OBRing_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBRing * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBRing * >::const_reference std_vector_Sl_OpenBabel_OBRing_Sm__Sg__getitem(std::vector< OpenBabel::OBRing * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__setitem(std::vector< OpenBabel::OBRing * > *self,int index,OpenBabel::OBRing *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__AddRange(std::vector< OpenBabel::OBRing * > *self,std::vector< OpenBabel::OBRing * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBRing * > *std_vector_Sl_OpenBabel_OBRing_Sm__Sg__GetRange(std::vector< OpenBabel::OBRing * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBRing * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Insert(std::vector< OpenBabel::OBRing * > *self,int index,OpenBabel::OBRing *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__InsertRange(std::vector< OpenBabel::OBRing * > *self,int index,std::vector< OpenBabel::OBRing * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBRing * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBRing * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBRing * > *std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Repeat(OpenBabel::OBRing *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBRing * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBRing * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBRing * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRing_Sm__Sg__SetRange(std::vector< OpenBabel::OBRing * > *self,int index,std::vector< OpenBabel::OBRing * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Contains(std::vector< OpenBabel::OBRing * > *self,OpenBabel::OBRing *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBRing_Sm__Sg__IndexOf(std::vector< OpenBabel::OBRing * > *self,OpenBabel::OBRing *const &value){
        int index = -1;
        std::vector< OpenBabel::OBRing * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBRing_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBRing * > *self,OpenBabel::OBRing *const &value){
        int index = -1;
        std::vector< OpenBabel::OBRing * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Remove(std::vector< OpenBabel::OBRing * > *self,OpenBabel::OBRing *const &value){
        std::vector< OpenBabel::OBRing * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::OBGenericData * > *new_std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBGenericData * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBGenericData * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBGenericData *std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBGenericData * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBGenericData * >::const_reference std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__getitem(std::vector< OpenBabel::OBGenericData * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__setitem(std::vector< OpenBabel::OBGenericData * > *self,int index,OpenBabel::OBGenericData *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__AddRange(std::vector< OpenBabel::OBGenericData * > *self,std::vector< OpenBabel::OBGenericData * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBGenericData * > *std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__GetRange(std::vector< OpenBabel::OBGenericData * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBGenericData * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Insert(std::vector< OpenBabel::OBGenericData * > *self,int index,OpenBabel::OBGenericData *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__InsertRange(std::vector< OpenBabel::OBGenericData * > *self,int index,std::vector< OpenBabel::OBGenericData * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBGenericData * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBGenericData * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBGenericData * > *std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Repeat(OpenBabel::OBGenericData *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBGenericData * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBGenericData * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBGenericData * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__SetRange(std::vector< OpenBabel::OBGenericData * > *self,int index,std::vector< OpenBabel::OBGenericData * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Contains(std::vector< OpenBabel::OBGenericData * > *self,OpenBabel::OBGenericData *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__IndexOf(std::vector< OpenBabel::OBGenericData * > *self,OpenBabel::OBGenericData *const &value){
        int index = -1;
        std::vector< OpenBabel::OBGenericData * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBGenericData * > *self,OpenBabel::OBGenericData *const &value){
        int index = -1;
        std::vector< OpenBabel::OBGenericData * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Remove(std::vector< OpenBabel::OBGenericData * > *self,OpenBabel::OBGenericData *const &value){
        std::vector< OpenBabel::OBGenericData * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::OBInternalCoord * > *new_std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBInternalCoord * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBInternalCoord * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBInternalCoord *std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBInternalCoord * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBInternalCoord * >::const_reference std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__getitem(std::vector< OpenBabel::OBInternalCoord * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__setitem(std::vector< OpenBabel::OBInternalCoord * > *self,int index,OpenBabel::OBInternalCoord *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__AddRange(std::vector< OpenBabel::OBInternalCoord * > *self,std::vector< OpenBabel::OBInternalCoord * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBInternalCoord * > *std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__GetRange(std::vector< OpenBabel::OBInternalCoord * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBInternalCoord * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Insert(std::vector< OpenBabel::OBInternalCoord * > *self,int index,OpenBabel::OBInternalCoord *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__InsertRange(std::vector< OpenBabel::OBInternalCoord * > *self,int index,std::vector< OpenBabel::OBInternalCoord * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBInternalCoord * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBInternalCoord * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBInternalCoord * > *std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Repeat(OpenBabel::OBInternalCoord *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBInternalCoord * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBInternalCoord * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBInternalCoord * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__SetRange(std::vector< OpenBabel::OBInternalCoord * > *self,int index,std::vector< OpenBabel::OBInternalCoord * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Contains(std::vector< OpenBabel::OBInternalCoord * > *self,OpenBabel::OBInternalCoord *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__IndexOf(std::vector< OpenBabel::OBInternalCoord * > *self,OpenBabel::OBInternalCoord *const &value){
        int index = -1;
        std::vector< OpenBabel::OBInternalCoord * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBInternalCoord * > *self,OpenBabel::OBInternalCoord *const &value){
        int index = -1;
        std::vector< OpenBabel::OBInternalCoord * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Remove(std::vector< OpenBabel::OBInternalCoord * > *self,OpenBabel::OBInternalCoord *const &value){
        std::vector< OpenBabel::OBInternalCoord * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::OBAtom * > *new_std_vector_Sl_OpenBabel_OBAtom_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBAtom * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBAtom * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBAtom *std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBAtom * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBAtom * >::const_reference std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__getitem(std::vector< OpenBabel::OBAtom * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__setitem(std::vector< OpenBabel::OBAtom * > *self,int index,OpenBabel::OBAtom *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__AddRange(std::vector< OpenBabel::OBAtom * > *self,std::vector< OpenBabel::OBAtom * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBAtom * > *std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__GetRange(std::vector< OpenBabel::OBAtom * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBAtom * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Insert(std::vector< OpenBabel::OBAtom * > *self,int index,OpenBabel::OBAtom *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__InsertRange(std::vector< OpenBabel::OBAtom * > *self,int index,std::vector< OpenBabel::OBAtom * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBAtom * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBAtom * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBAtom * > *std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Repeat(OpenBabel::OBAtom *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBAtom * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBAtom * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBAtom * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__SetRange(std::vector< OpenBabel::OBAtom * > *self,int index,std::vector< OpenBabel::OBAtom * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Contains(std::vector< OpenBabel::OBAtom * > *self,OpenBabel::OBAtom *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__IndexOf(std::vector< OpenBabel::OBAtom * > *self,OpenBabel::OBAtom *const &value){
        int index = -1;
        std::vector< OpenBabel::OBAtom * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBAtom * > *self,OpenBabel::OBAtom *const &value){
        int index = -1;
        std::vector< OpenBabel::OBAtom * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Remove(std::vector< OpenBabel::OBAtom * > *self,OpenBabel::OBAtom *const &value){
        std::vector< OpenBabel::OBAtom * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::OBBond * > *new_std_vector_Sl_OpenBabel_OBBond_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBBond * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBBond * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBBond *std_vector_Sl_OpenBabel_OBBond_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBBond * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBBond * >::const_reference std_vector_Sl_OpenBabel_OBBond_Sm__Sg__getitem(std::vector< OpenBabel::OBBond * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__setitem(std::vector< OpenBabel::OBBond * > *self,int index,OpenBabel::OBBond *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__AddRange(std::vector< OpenBabel::OBBond * > *self,std::vector< OpenBabel::OBBond * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBBond * > *std_vector_Sl_OpenBabel_OBBond_Sm__Sg__GetRange(std::vector< OpenBabel::OBBond * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBBond * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Insert(std::vector< OpenBabel::OBBond * > *self,int index,OpenBabel::OBBond *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__InsertRange(std::vector< OpenBabel::OBBond * > *self,int index,std::vector< OpenBabel::OBBond * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBBond * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBBond * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBBond * > *std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Repeat(OpenBabel::OBBond *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBBond * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBBond * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBBond * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBBond_Sm__Sg__SetRange(std::vector< OpenBabel::OBBond * > *self,int index,std::vector< OpenBabel::OBBond * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Contains(std::vector< OpenBabel::OBBond * > *self,OpenBabel::OBBond *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBBond_Sm__Sg__IndexOf(std::vector< OpenBabel::OBBond * > *self,OpenBabel::OBBond *const &value){
        int index = -1;
        std::vector< OpenBabel::OBBond * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBBond_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBBond * > *self,OpenBabel::OBBond *const &value){
        int index = -1;
        std::vector< OpenBabel::OBBond * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Remove(std::vector< OpenBabel::OBBond * > *self,OpenBabel::OBBond *const &value){
        std::vector< OpenBabel::OBBond * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< OpenBabel::OBRotor * > *new_std_vector_Sl_OpenBabel_OBRotor_Sm__Sg___SWIG_2(int capacity){
        std::vector< OpenBabel::OBRotor * >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< OpenBabel::OBRotor * >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN OpenBabel::OBRotor *std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__getitemcopy(std::vector< OpenBabel::OBRotor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< OpenBabel::OBRotor * >::const_reference std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__getitem(std::vector< OpenBabel::OBRotor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__setitem(std::vector< OpenBabel::OBRotor * > *self,int index,OpenBabel::OBRotor *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__AddRange(std::vector< OpenBabel::OBRotor * > *self,std::vector< OpenBabel::OBRotor * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< OpenBabel::OBRotor * > *std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__GetRange(std::vector< OpenBabel::OBRotor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< OpenBabel::OBRotor * >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Insert(std::vector< OpenBabel::OBRotor * > *self,int index,OpenBabel::OBRotor *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__InsertRange(std::vector< OpenBabel::OBRotor * > *self,int index,std::vector< OpenBabel::OBRotor * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__RemoveAt(std::vector< OpenBabel::OBRotor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__RemoveRange(std::vector< OpenBabel::OBRotor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< OpenBabel::OBRotor * > *std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Repeat(OpenBabel::OBRotor *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< OpenBabel::OBRotor * >(count, value);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Reverse__SWIG_0(std::vector< OpenBabel::OBRotor * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Reverse__SWIG_1(std::vector< OpenBabel::OBRotor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__SetRange(std::vector< OpenBabel::OBRotor * > *self,int index,std::vector< OpenBabel::OBRotor * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Contains(std::vector< OpenBabel::OBRotor * > *self,OpenBabel::OBRotor *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__IndexOf(std::vector< OpenBabel::OBRotor * > *self,OpenBabel::OBRotor *const &value){
        int index = -1;
        std::vector< OpenBabel::OBRotor * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__LastIndexOf(std::vector< OpenBabel::OBRotor * > *self,OpenBabel::OBRotor *const &value){
        int index = -1;
        std::vector< OpenBabel::OBRotor * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Remove(std::vector< OpenBabel::OBRotor * > *self,OpenBabel::OBRotor *const &value){
        std::vector< OpenBabel::OBRotor * >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN OpenBabel::OBAngleData *OpenBabel_OBGenericData_ToAngleData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBAngleData *) self;
    }
SWIGINTERN OpenBabel::OBAtomClassData *OpenBabel_OBGenericData_ToAtomClassData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBAtomClassData *) self;
    }
SWIGINTERN OpenBabel::OBChiralData *OpenBabel_OBGenericData_ToChiralData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBChiralData *) self;
    }
SWIGINTERN OpenBabel::OBCommentData *OpenBabel_OBGenericData_ToCommentData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBCommentData *) self;
    }
SWIGINTERN OpenBabel::OBConformerData *OpenBabel_OBGenericData_ToConformerData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBConformerData *) self;
    }
SWIGINTERN OpenBabel::OBExternalBondData *OpenBabel_OBGenericData_ToExternalBondData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBExternalBondData *) self;
    }
SWIGINTERN OpenBabel::OBGridData *OpenBabel_OBGenericData_ToGridData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBGridData *) self;
    }
SWIGINTERN OpenBabel::OBMatrixData *OpenBabel_OBGenericData_ToMatrixData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBMatrixData *) self;
    }
SWIGINTERN OpenBabel::OBNasaThermoData *OpenBabel_OBGenericData_ToNasaThermoData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBNasaThermoData *) self;
    }
SWIGINTERN OpenBabel::OBPairData *OpenBabel_OBGenericData_ToPairData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBPairData *) self;
    }
SWIGINTERN OpenBabel::OBRateData *OpenBabel_OBGenericData_ToRateData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBRateData *) self;
    }
SWIGINTERN OpenBabel::OBRotamerList *OpenBabel_OBGenericData_ToRotamerList(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBRotamerList *) self;
    }
SWIGINTERN OpenBabel::OBRotationData *OpenBabel_OBGenericData_ToRotationData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBRotationData *) self;
    }
SWIGINTERN OpenBabel::OBSetData *OpenBabel_OBGenericData_ToSetData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBSetData *) self;
    }
SWIGINTERN OpenBabel::OBSymmetryData *OpenBabel_OBGenericData_ToSymmetryData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBSymmetryData *) self;
    }
SWIGINTERN OpenBabel::OBTorsionData *OpenBabel_OBGenericData_ToTorsionData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBTorsionData *) self;
    }
SWIGINTERN OpenBabel::OBUnitCell *OpenBabel_OBGenericData_ToUnitCell(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBUnitCell *) self;
    }
SWIGINTERN OpenBabel::OBVectorData *OpenBabel_OBGenericData_ToVectorData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBVectorData *) self;
    }
SWIGINTERN OpenBabel::OBVibrationData *OpenBabel_OBGenericData_ToVibrationData(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBVibrationData *) self;
    }
SWIGINTERN OpenBabel::OBVirtualBond *OpenBabel_OBGenericData_ToVirtualBond(OpenBabel::OBGenericData *self){
	    return (OpenBabel::OBVirtualBond *) self;
    }
SWIGINTERN std::vector< OpenBabel::OBRotor * > OpenBabel_OBRotorList_GetRotors(OpenBabel::OBRotorList *self){
		std::vector<OpenBabel::OBRotor*> rotors(self->BeginRotors(),self->EndRotors());
		return rotors;
	}

#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void * SWIGSTDCALL CSharp_new_CDoubleArray(int jarg1) { void * jresult ; int arg1 ; CDoubleArray *result = 0 ;
  arg1 = (int)jarg1;  result = (CDoubleArray *)new_CDoubleArray(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_CDoubleArray(void * jarg1) { CDoubleArray *arg1 = (CDoubleArray *) 0 ;
  arg1 = (CDoubleArray *)jarg1;  delete_CDoubleArray(arg1); }
SWIGEXPORT double SWIGSTDCALL CSharp_CDoubleArray_getitem(void * jarg1, int jarg2) { double jresult ;
  CDoubleArray *arg1 = (CDoubleArray *) 0 ; int arg2 ; double result; arg1 = (CDoubleArray *)jarg1;  arg2 = (int)jarg2; 
  result = (double)CDoubleArray_getitem(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_CDoubleArray_setitem(void * jarg1, int jarg2, double jarg3) {
  CDoubleArray *arg1 = (CDoubleArray *) 0 ; int arg2 ; double arg3 ; arg1 = (CDoubleArray *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (double)jarg3;  CDoubleArray_setitem(arg1,arg2,arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_CDoubleArray_cast(void * jarg1) { void * jresult ;
  CDoubleArray *arg1 = (CDoubleArray *) 0 ; double *result = 0 ; arg1 = (CDoubleArray *)jarg1; 
  result = (double *)CDoubleArray_cast(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_CDoubleArray_frompointer(void * jarg1) { void * jresult ; double *arg1 = (double *) 0 ;
  CDoubleArray *result = 0 ; arg1 = (double *)jarg1;  result = (CDoubleArray *)CDoubleArray_frompointer(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_CIntArray(int jarg1) { void * jresult ; int arg1 ; CIntArray *result = 0 ;
  arg1 = (int)jarg1;  result = (CIntArray *)new_CIntArray(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_CIntArray(void * jarg1) { CIntArray *arg1 = (CIntArray *) 0 ;
  arg1 = (CIntArray *)jarg1;  delete_CIntArray(arg1); }
SWIGEXPORT int SWIGSTDCALL CSharp_CIntArray_getitem(void * jarg1, int jarg2) { int jresult ; CIntArray *arg1 = (CIntArray *) 0 ;
  int arg2 ; int result; arg1 = (CIntArray *)jarg1;  arg2 = (int)jarg2;  result = (int)CIntArray_getitem(arg1,arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_CIntArray_setitem(void * jarg1, int jarg2, int jarg3) { CIntArray *arg1 = (CIntArray *) 0 ;
  int arg2 ; int arg3 ; arg1 = (CIntArray *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  CIntArray_setitem(arg1,arg2,arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_CIntArray_cast(void * jarg1) { void * jresult ; CIntArray *arg1 = (CIntArray *) 0 ;
  int *result = 0 ; arg1 = (CIntArray *)jarg1;  result = (int *)CIntArray_cast(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_CIntArray_frompointer(void * jarg1) { void * jresult ; int *arg1 = (int *) 0 ;
  CIntArray *result = 0 ; arg1 = (int *)jarg1;  result = (CIntArray *)CIntArray_frompointer(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_CByteArray(int jarg1) { void * jresult ; int arg1 ; CByteArray *result = 0 ;
  arg1 = (int)jarg1;  result = (CByteArray *)new_CByteArray(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_CByteArray(void * jarg1) { CByteArray *arg1 = (CByteArray *) 0 ;
  arg1 = (CByteArray *)jarg1;  delete_CByteArray(arg1); }
SWIGEXPORT unsigned char SWIGSTDCALL CSharp_CByteArray_getitem(void * jarg1, int jarg2) { unsigned char jresult ;
  CByteArray *arg1 = (CByteArray *) 0 ; int arg2 ; unsigned char result; arg1 = (CByteArray *)jarg1;  arg2 = (int)jarg2; 
  result = (unsigned char)CByteArray_getitem(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_CByteArray_setitem(void * jarg1, int jarg2, unsigned char jarg3) {
  CByteArray *arg1 = (CByteArray *) 0 ; int arg2 ; unsigned char arg3 ; arg1 = (CByteArray *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (unsigned char)jarg3;  CByteArray_setitem(arg1,arg2,arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_CByteArray_cast(void * jarg1) { void * jresult ; CByteArray *arg1 = (CByteArray *) 0 ;
  unsigned char *result = 0 ; arg1 = (CByteArray *)jarg1;  result = (unsigned char *)CByteArray_cast(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_CByteArray_frompointer(void * jarg1) { void * jresult ;
  unsigned char *arg1 = (unsigned char *) 0 ; CByteArray *result = 0 ; arg1 = (unsigned char *)jarg1; 
  result = (CByteArray *)CByteArray_frompointer(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_CUIntArray(int jarg1) { void * jresult ; int arg1 ; CUIntArray *result = 0 ;
  arg1 = (int)jarg1;  result = (CUIntArray *)new_CUIntArray(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_CUIntArray(void * jarg1) { CUIntArray *arg1 = (CUIntArray *) 0 ;
  arg1 = (CUIntArray *)jarg1;  delete_CUIntArray(arg1); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CUIntArray_getitem(void * jarg1, int jarg2) { unsigned int jresult ;
  CUIntArray *arg1 = (CUIntArray *) 0 ; int arg2 ; unsigned int result; arg1 = (CUIntArray *)jarg1;  arg2 = (int)jarg2; 
  result = (unsigned int)CUIntArray_getitem(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_CUIntArray_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  CUIntArray *arg1 = (CUIntArray *) 0 ; int arg2 ; unsigned int arg3 ; arg1 = (CUIntArray *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (unsigned int)jarg3;  CUIntArray_setitem(arg1,arg2,arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_CUIntArray_cast(void * jarg1) { void * jresult ; CUIntArray *arg1 = (CUIntArray *) 0 ;
  unsigned int *result = 0 ; arg1 = (CUIntArray *)jarg1;  result = (unsigned int *)CUIntArray_cast(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_CUIntArray_frompointer(void * jarg1) { void * jresult ;
  unsigned int *arg1 = (unsigned int *) 0 ; CUIntArray *result = 0 ; arg1 = (unsigned int *)jarg1; 
  result = (CUIntArray *)CUIntArray_frompointer(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_Clear(void * jarg1) { std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  arg1 = (std::vector< int > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_Add(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int *arg2 = 0 ; int temp2 ; arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2;  arg2 = &temp2;  (arg1)->push_back((int const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorInt_size(void * jarg1) { unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; std::vector< int >::size_type result;
  arg1 = (std::vector< int > *)jarg1;  result = ((std::vector< int > const *)arg1)->size(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorInt_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; std::vector< int >::size_type result;
  arg1 = (std::vector< int > *)jarg1;  result = ((std::vector< int > const *)arg1)->capacity();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; std::vector< int >::size_type arg2 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (std::vector< int >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorInt__SWIG_0() { void * jresult ; std::vector< int > *result = 0 ;
  result = (std::vector< int > *)new std::vector< int >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorInt__SWIG_1(void * jarg1) { void * jresult ; std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ; arg1 = (std::vector< int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0; }   result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorInt__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< int > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorInt_getitemcopy(void * jarg1, int jarg2) { int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int result; arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2;  try { result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorInt_getitem(void * jarg1, int jarg2) { int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int *result = 0 ; arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2;  try { result = (int *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = *result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_setitem(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int *arg3 = 0 ; int temp3 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (int)jarg3;  arg3 = &temp3;  try {
    std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_AddRange(void * jarg1, void * jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorInt_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int arg3 ; std::vector< int > *result = 0 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__GetRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_Insert(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int *arg3 = 0 ; int temp3 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (int)jarg3;  arg3 = &temp3;  try {
    std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; std::vector< int > *arg3 = 0 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   try { std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2; 
  try { std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int arg3 ; arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try { std_vector_Sl_int_Sg__RemoveRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorInt_Repeat(int jarg1, int jarg2) { void * jresult ; int *arg1 = 0 ; int arg2 ;
  int temp1 ; std::vector< int > *result = 0 ; temp1 = (int)jarg1;  arg1 = &temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_Reverse__SWIG_0(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; arg1 = (std::vector< int > *)jarg1; 
  std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; int arg3 ; arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try { std_vector_Sl_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorInt_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int arg2 ; std::vector< int > *arg3 = 0 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   try { std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorInt_Contains(void * jarg1, int jarg2) { unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int *arg2 = 0 ; int temp2 ; bool result;
  arg1 = (std::vector< int > *)jarg1;  temp2 = (int)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorInt_IndexOf(void * jarg1, int jarg2) { int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int *arg2 = 0 ; int temp2 ; int result;
  arg1 = (std::vector< int > *)jarg1;  temp2 = (int)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorInt_LastIndexOf(void * jarg1, int jarg2) { int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int *arg2 = 0 ; int temp2 ; int result;
  arg1 = (std::vector< int > *)jarg1;  temp2 = (int)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorInt_Remove(void * jarg1, int jarg2) { unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; int *arg2 = 0 ; int temp2 ; bool result;
  arg1 = (std::vector< int > *)jarg1;  temp2 = (int)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorInt(void * jarg1) { std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  arg1 = (std::vector< int > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_Clear(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; std::vector< int > *arg2 = 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< int > const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecInt_size(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type result; arg1 = (std::vector< std::vector< int > > *)jarg1; 
  result = ((std::vector< std::vector< int > > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecInt_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type result; arg1 = (std::vector< std::vector< int > > *)jarg1; 
  result = ((std::vector< std::vector< int > > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ; arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (std::vector< std::vector< int > >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecInt__SWIG_0() { void * jresult ;
  std::vector< std::vector< int > > *result = 0 ;
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecInt__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< std::vector< int > > *arg1 = 0 ; std::vector< std::vector< int > > *result = 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return 0; }  
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >((std::vector< std::vector< int > > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecInt__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< std::vector< int > > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< std::vector< int > > *)new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecInt_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; std::vector< int > result;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new std::vector< int >((const std::vector< int > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecInt_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ;
  std::vector< int > *result = 0 ; arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (std::vector< int > *) &std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; std::vector< int > *arg3 = 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(arg1,arg2,(std::vector< int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > > *arg2 = 0 ; arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (std::vector< std::vector< int > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ; }   std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(arg1,(std::vector< std::vector< int > > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecInt_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; int arg3 ;
  std::vector< std::vector< int > > *result = 0 ; arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; std::vector< int > *arg3 = 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(arg1,arg2,(std::vector< int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ;
  std::vector< std::vector< int > > *arg3 = 0 ; arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecInt_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< int > *arg1 = 0 ; int arg2 ; std::vector< std::vector< int > > *result = 0 ; arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat((std::vector< int > const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecInt_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ; int arg2 ;
  std::vector< std::vector< int > > *arg3 = 0 ; arg1 = (std::vector< std::vector< int > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorVecInt(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  arg1 = (std::vector< std::vector< int > > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_Clear(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; arg1 = (std::vector< unsigned int > *)jarg1; 
  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_Add(void * jarg1, unsigned int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; unsigned int *arg2 = 0 ; unsigned int temp2 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  temp2 = (unsigned int)jarg2;  arg2 = &temp2; 
  (arg1)->push_back((unsigned int const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorUInt_size(void * jarg1) { unsigned long jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::size_type result;
  arg1 = (std::vector< unsigned int > *)jarg1;  result = ((std::vector< unsigned int > const *)arg1)->size();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorUInt_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::size_type result;
  arg1 = (std::vector< unsigned int > *)jarg1;  result = ((std::vector< unsigned int > const *)arg1)->capacity();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::size_type arg2 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (std::vector< unsigned int >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUInt__SWIG_0() { void * jresult ; std::vector< unsigned int > *result = 0 ;
  result = (std::vector< unsigned int > *)new std::vector< unsigned int >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUInt__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ; std::vector< unsigned int > *result = 0 ; arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }  
  result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUInt__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< unsigned int > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUInt_getitemcopy(void * jarg1, int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; unsigned int result;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUInt_getitem(void * jarg1, int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; unsigned int *result = 0 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = *result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; unsigned int *arg3 = 0 ;
  unsigned int temp3 ; arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3;  try { std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_AddRange(void * jarg1, void * jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int > *arg2 = 0 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorUInt_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; int arg3 ;
  std::vector< unsigned int > *result = 0 ; arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try { result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; unsigned int *arg3 = 0 ;
  unsigned int temp3 ; arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3;  try { std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; std::vector< unsigned int > *arg3 = 0 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   try { std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_RemoveAt(void * jarg1, int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  try { std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorUInt_Repeat(unsigned int jarg1, int jarg2) { void * jresult ;
  unsigned int *arg1 = 0 ; int arg2 ; unsigned int temp1 ; std::vector< unsigned int > *result = 0 ;
  temp1 = (unsigned int)jarg1;  arg1 = &temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_Reverse__SWIG_0(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; arg1 = (std::vector< unsigned int > *)jarg1; 
  std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUInt_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ; std::vector< unsigned int > *arg3 = 0 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   try { std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUInt_Contains(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; unsigned int *arg2 = 0 ; unsigned int temp2 ;
  bool result; arg1 = (std::vector< unsigned int > *)jarg1;  temp2 = (unsigned int)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorUInt_IndexOf(void * jarg1, unsigned int jarg2) { int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; unsigned int *arg2 = 0 ; unsigned int temp2 ;
  int result; arg1 = (std::vector< unsigned int > *)jarg1;  temp2 = (unsigned int)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorUInt_LastIndexOf(void * jarg1, unsigned int jarg2) { int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; unsigned int *arg2 = 0 ; unsigned int temp2 ;
  int result; arg1 = (std::vector< unsigned int > *)jarg1;  temp2 = (unsigned int)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUInt_Remove(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; unsigned int *arg2 = 0 ; unsigned int temp2 ;
  bool result; arg1 = (std::vector< unsigned int > *)jarg1;  temp2 = (unsigned int)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorUInt(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; arg1 = (std::vector< unsigned int > *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_Clear(void * jarg1) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< unsigned int > const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecUInt_size(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  std::vector< std::vector< unsigned int > >::size_type result; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  result = ((std::vector< std::vector< unsigned int > > const *)arg1)->size(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecUInt_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  std::vector< std::vector< unsigned int > >::size_type result; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  result = ((std::vector< std::vector< unsigned int > > const *)arg1)->capacity(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  std::vector< std::vector< unsigned int > >::size_type arg2 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (std::vector< std::vector< unsigned int > >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecUInt__SWIG_0() { void * jresult ;
  std::vector< std::vector< unsigned int > > *result = 0 ;
  result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecUInt__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ; std::vector< std::vector< unsigned int > > *result = 0 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > const & type is null", 0);
    return 0; }  
  result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >((std::vector< std::vector< unsigned int > > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecUInt__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< std::vector< unsigned int > > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< std::vector< unsigned int > > *)new_std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg___SWIG_2(arg1);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecUInt_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< unsigned int > result; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecUInt_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< unsigned int > *result = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2; 
  try { result = (std::vector< unsigned int > *) &std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__setitem(arg1,arg2,(std::vector< unsigned int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  std::vector< std::vector< unsigned int > > *arg2 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (std::vector< std::vector< unsigned int > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > const & type is null", 0);
    return ; }  
  std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__AddRange(arg1,(std::vector< std::vector< unsigned int > > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecUInt_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ; int arg3 ;
  std::vector< std::vector< unsigned int > > *result = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< std::vector< unsigned int > > *)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__GetRange(arg1,arg2,arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Insert(arg1,arg2,(std::vector< unsigned int > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< std::vector< unsigned int > > *arg3 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< std::vector< unsigned int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< unsigned int > > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecUInt_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ; int arg2 ; std::vector< std::vector< unsigned int > > *result = 0 ;
  arg1 = (std::vector< unsigned int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< std::vector< unsigned int > > *)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Repeat((std::vector< unsigned int > const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecUInt_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ; int arg2 ;
  std::vector< std::vector< unsigned int > > *arg3 = 0 ; arg1 = (std::vector< std::vector< unsigned int > > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< std::vector< unsigned int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< unsigned int > > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorVecUInt(void * jarg1) {
  std::vector< std::vector< unsigned int > > *arg1 = (std::vector< std::vector< unsigned int > > *) 0 ;
  arg1 = (std::vector< std::vector< unsigned int > > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_Clear(void * jarg1) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; arg1 = (std::vector< unsigned short > *)jarg1; 
  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_Add(void * jarg1, unsigned short jarg2) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; unsigned short *arg2 = 0 ; unsigned short temp2 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  temp2 = (unsigned short)jarg2;  arg2 = &temp2; 
  (arg1)->push_back((unsigned short const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorUShort_size(void * jarg1) { unsigned long jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; std::vector< unsigned short >::size_type result;
  arg1 = (std::vector< unsigned short > *)jarg1;  result = ((std::vector< unsigned short > const *)arg1)->size();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorUShort_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; std::vector< unsigned short >::size_type result;
  arg1 = (std::vector< unsigned short > *)jarg1;  result = ((std::vector< unsigned short > const *)arg1)->capacity();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; std::vector< unsigned short >::size_type arg2 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (std::vector< unsigned short >::size_type)jarg2; 
  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUShort__SWIG_0() { void * jresult ; std::vector< unsigned short > *result = 0 ;
  result = (std::vector< unsigned short > *)new std::vector< unsigned short >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUShort__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< unsigned short > *arg1 = 0 ; std::vector< unsigned short > *result = 0 ;
  arg1 = (std::vector< unsigned short > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned short > const & type is null", 0);
    return 0; }  
  result = (std::vector< unsigned short > *)new std::vector< unsigned short >((std::vector< unsigned short > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorUShort__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< unsigned short > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< unsigned short > *)new_std_vector_Sl_unsigned_SS_short_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_VectorUShort_getitemcopy(void * jarg1, int jarg2) { unsigned short jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; unsigned short result;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (unsigned short)std_vector_Sl_unsigned_SS_short_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = result;  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_VectorUShort_getitem(void * jarg1, int jarg2) { unsigned short jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; unsigned short *result = 0 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (unsigned short *) &std_vector_Sl_unsigned_SS_short_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = *result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_setitem(void * jarg1, int jarg2, unsigned short jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; unsigned short *arg3 = 0 ;
  unsigned short temp3 ; arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  temp3 = (unsigned short)jarg3; 
  arg3 = &temp3;  try { std_vector_Sl_unsigned_SS_short_Sg__setitem(arg1,arg2,(unsigned short const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_AddRange(void * jarg1, void * jarg2) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; std::vector< unsigned short > *arg2 = 0 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (std::vector< unsigned short > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned short > const & type is null", 0);
    return ; }   std_vector_Sl_unsigned_SS_short_Sg__AddRange(arg1,(std::vector< unsigned short > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorUShort_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; int arg3 ;
  std::vector< unsigned short > *result = 0 ; arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< unsigned short > *)std_vector_Sl_unsigned_SS_short_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_Insert(void * jarg1, int jarg2, unsigned short jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; unsigned short *arg3 = 0 ;
  unsigned short temp3 ; arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  temp3 = (unsigned short)jarg3; 
  arg3 = &temp3;  try { std_vector_Sl_unsigned_SS_short_Sg__Insert(arg1,arg2,(unsigned short const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ;
  std::vector< unsigned short > *arg3 = 0 ; arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned short > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned short > const & type is null", 0);
    return ; }   try { std_vector_Sl_unsigned_SS_short_Sg__InsertRange(arg1,arg2,(std::vector< unsigned short > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_RemoveAt(void * jarg1, int jarg2) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_unsigned_SS_short_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_unsigned_SS_short_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorUShort_Repeat(unsigned short jarg1, int jarg2) { void * jresult ;
  unsigned short *arg1 = 0 ; int arg2 ; unsigned short temp1 ; std::vector< unsigned short > *result = 0 ;
  temp1 = (unsigned short)jarg1;  arg1 = &temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< unsigned short > *)std_vector_Sl_unsigned_SS_short_Sg__Repeat((unsigned short const &)*arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_Reverse__SWIG_0(void * jarg1) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; arg1 = (std::vector< unsigned short > *)jarg1; 
  std_vector_Sl_unsigned_SS_short_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_unsigned_SS_short_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorUShort_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; int arg2 ;
  std::vector< unsigned short > *arg3 = 0 ; arg1 = (std::vector< unsigned short > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned short > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned short > const & type is null", 0);
    return ; }   try { std_vector_Sl_unsigned_SS_short_Sg__SetRange(arg1,arg2,(std::vector< unsigned short > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUShort_Contains(void * jarg1, unsigned short jarg2) { unsigned int jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; unsigned short *arg2 = 0 ; unsigned short temp2 ;
  bool result; arg1 = (std::vector< unsigned short > *)jarg1;  temp2 = (unsigned short)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_unsigned_SS_short_Sg__Contains(arg1,(unsigned short const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorUShort_IndexOf(void * jarg1, unsigned short jarg2) { int jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; unsigned short *arg2 = 0 ; unsigned short temp2 ;
  int result; arg1 = (std::vector< unsigned short > *)jarg1;  temp2 = (unsigned short)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_unsigned_SS_short_Sg__IndexOf(arg1,(unsigned short const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorUShort_LastIndexOf(void * jarg1, unsigned short jarg2) { int jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; unsigned short *arg2 = 0 ; unsigned short temp2 ;
  int result; arg1 = (std::vector< unsigned short > *)jarg1;  temp2 = (unsigned short)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_unsigned_SS_short_Sg__LastIndexOf(arg1,(unsigned short const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorUShort_Remove(void * jarg1, unsigned short jarg2) { unsigned int jresult ;
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; unsigned short *arg2 = 0 ; unsigned short temp2 ;
  bool result; arg1 = (std::vector< unsigned short > *)jarg1;  temp2 = (unsigned short)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_unsigned_SS_short_Sg__Remove(arg1,(unsigned short const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorUShort(void * jarg1) {
  std::vector< unsigned short > *arg1 = (std::vector< unsigned short > *) 0 ; arg1 = (std::vector< unsigned short > *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_Clear(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; arg1 = (std::vector< double > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_Add(void * jarg1, double jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; double *arg2 = 0 ; double temp2 ;
  arg1 = (std::vector< double > *)jarg1;  temp2 = (double)jarg2;  arg2 = &temp2;  (arg1)->push_back((double const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorDouble_size(void * jarg1) { unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; std::vector< double >::size_type result;
  arg1 = (std::vector< double > *)jarg1;  result = ((std::vector< double > const *)arg1)->size();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorDouble_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; std::vector< double >::size_type result;
  arg1 = (std::vector< double > *)jarg1;  result = ((std::vector< double > const *)arg1)->capacity();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; std::vector< double >::size_type arg2 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (std::vector< double >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorDouble__SWIG_0() { void * jresult ; std::vector< double > *result = 0 ;
  result = (std::vector< double > *)new std::vector< double >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorDouble__SWIG_1(void * jarg1) { void * jresult ; std::vector< double > *arg1 = 0 ;
  std::vector< double > *result = 0 ; arg1 = (std::vector< double > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return 0; }   result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorDouble__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< double > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(arg1);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_VectorDouble_getitemcopy(void * jarg1, int jarg2) { double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; double result; arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2;  try { result = (double)std_vector_Sl_double_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_VectorDouble_getitem(void * jarg1, int jarg2) { double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; double *result = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (double *) &std_vector_Sl_double_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = *result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_setitem(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; double *arg3 = 0 ; double temp3 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  temp3 = (double)jarg3;  arg3 = &temp3;  try {
    std_vector_Sl_double_Sg__setitem(arg1,arg2,(double const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_AddRange(void * jarg1, void * jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   std_vector_Sl_double_Sg__AddRange(arg1,(std::vector< double > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorDouble_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; int arg3 ; std::vector< double > *result = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< double > *)std_vector_Sl_double_Sg__GetRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_Insert(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; double *arg3 = 0 ; double temp3 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  temp3 = (double)jarg3;  arg3 = &temp3;  try {
    std_vector_Sl_double_Sg__Insert(arg1,arg2,(double const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; std::vector< double > *arg3 = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   try { std_vector_Sl_double_Sg__InsertRange(arg1,arg2,(std::vector< double > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_RemoveAt(void * jarg1, int jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2;  try { std_vector_Sl_double_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; int arg3 ; arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try { std_vector_Sl_double_Sg__RemoveRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorDouble_Repeat(double jarg1, int jarg2) { void * jresult ; double *arg1 = 0 ;
  int arg2 ; double temp1 ; std::vector< double > *result = 0 ; temp1 = (double)jarg1;  arg1 = &temp1;  arg2 = (int)jarg2; 
  try { result = (std::vector< double > *)std_vector_Sl_double_Sg__Repeat((double const &)*arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_Reverse__SWIG_0(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; arg1 = (std::vector< double > *)jarg1; 
  std_vector_Sl_double_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; int arg3 ; arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try { std_vector_Sl_double_Sg__Reverse__SWIG_1(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorDouble_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; int arg2 ; std::vector< double > *arg3 = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   try { std_vector_Sl_double_Sg__SetRange(arg1,arg2,(std::vector< double > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorDouble_Contains(void * jarg1, double jarg2) { unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; double *arg2 = 0 ; double temp2 ; bool result;
  arg1 = (std::vector< double > *)jarg1;  temp2 = (double)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_double_Sg__Contains(arg1,(double const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorDouble_IndexOf(void * jarg1, double jarg2) { int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; double *arg2 = 0 ; double temp2 ; int result;
  arg1 = (std::vector< double > *)jarg1;  temp2 = (double)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_double_Sg__IndexOf(arg1,(double const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorDouble_LastIndexOf(void * jarg1, double jarg2) { int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; double *arg2 = 0 ; double temp2 ; int result;
  arg1 = (std::vector< double > *)jarg1;  temp2 = (double)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorDouble_Remove(void * jarg1, double jarg2) { unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; double *arg2 = 0 ; double temp2 ; bool result;
  arg1 = (std::vector< double > *)jarg1;  temp2 = (double)jarg2;  arg2 = &temp2; 
  result = (bool)std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorDouble(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; arg1 = (std::vector< double > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_Clear(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< double > const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecDouble_size(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type result; arg1 = (std::vector< std::vector< double > > *)jarg1; 
  result = ((std::vector< std::vector< double > > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecDouble_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type result; arg1 = (std::vector< std::vector< double > > *)jarg1; 
  result = ((std::vector< std::vector< double > > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ; arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (std::vector< std::vector< double > >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecDouble__SWIG_0() { void * jresult ;
  std::vector< std::vector< double > > *result = 0 ;
  result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecDouble__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< std::vector< double > > *arg1 = 0 ; std::vector< std::vector< double > > *result = 0 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & type is null", 0);
    return 0; }  
  result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >((std::vector< std::vector< double > > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecDouble__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< std::vector< double > > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< std::vector< double > > *)new_std_vector_Sl_std_vector_Sl_double_Sg__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecDouble_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< double > result; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecDouble_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< double > *result = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (std::vector< double > *) &std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< double > *arg3 = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_vector_Sl_double_Sg__Sg__setitem(arg1,arg2,(std::vector< double > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (std::vector< std::vector< double > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & type is null", 0);
    return ; }   std_vector_Sl_std_vector_Sl_double_Sg__Sg__AddRange(arg1,(std::vector< std::vector< double > > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecDouble_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ; int arg3 ;
  std::vector< std::vector< double > > *result = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< std::vector< double > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< double > *arg3 = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_vector_Sl_double_Sg__Sg__Insert(arg1,arg2,(std::vector< double > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< double > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_double_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< double > > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_std_vector_Sl_double_Sg__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_double_Sg__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecDouble_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< double > *arg1 = 0 ; int arg2 ; std::vector< std::vector< double > > *result = 0 ;
  arg1 = (std::vector< double > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< std::vector< double > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__Repeat((std::vector< double > const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecDouble_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ; int arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ; arg1 = (std::vector< std::vector< double > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< double > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_double_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< double > > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorVecDouble(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  arg1 = (std::vector< std::vector< double > > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_Clear(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; arg1 = (std::vector< std::string > *)jarg1; 
  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_Add(void * jarg1, char * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string *arg2 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->push_back((std::string const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorString_size(void * jarg1) { unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::vector< std::string >::size_type result;
  arg1 = (std::vector< std::string > *)jarg1;  result = ((std::vector< std::string > const *)arg1)->size();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorString_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::vector< std::string >::size_type result;
  arg1 = (std::vector< std::string > *)jarg1;  result = ((std::vector< std::string > const *)arg1)->capacity();
  jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::vector< std::string >::size_type arg2 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (std::vector< std::string >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorString__SWIG_0() { void * jresult ; std::vector< std::string > *result = 0 ;
  result = (std::vector< std::string > *)new std::vector< std::string >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorString__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< std::string > *arg1 = 0 ; std::vector< std::string > *result = 0 ; arg1 = (std::vector< std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0; }  
  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorString__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< std::string > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(arg1);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_VectorString_getitemcopy(void * jarg1, int jarg2) { char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::string result;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_std_string_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_VectorString_getitem(void * jarg1, int jarg2) { char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::string *result = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (std::string *) &std_vector_Sl_std_string_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_setitem(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::string *arg3 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  try {
    std_vector_Sl_std_string_Sg__setitem(arg1,arg2,(std::string const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::vector< std::string > *arg2 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (std::vector< std::string > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ; }   std_vector_Sl_std_string_Sg__AddRange(arg1,(std::vector< std::string > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorString_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; int arg3 ;
  std::vector< std::string > *result = 0 ; arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  try { result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_Insert(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::string *arg3 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  try {
    std_vector_Sl_std_string_Sg__Insert(arg1,arg2,(std::string const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::vector< std::string > *arg3 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< std::string > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_string_Sg__InsertRange(arg1,arg2,(std::vector< std::string > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2;  try { std_vector_Sl_std_string_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_string_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorString_Repeat(char * jarg1, int jarg2) { void * jresult ; std::string *arg1 = 0 ;
  int arg2 ; std::vector< std::string > *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  arg2 = (int)jarg2;  try {
    result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__Repeat((std::string const &)*arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; arg1 = (std::vector< std::string > *)jarg1; 
  std_vector_Sl_std_string_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_string_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorString_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; int arg2 ; std::vector< std::string > *arg3 = 0 ;
  arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  arg3 = (std::vector< std::string > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ; }   try { std_vector_Sl_std_string_Sg__SetRange(arg1,arg2,(std::vector< std::string > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorString_Contains(void * jarg1, char * jarg2) { unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (std::vector< std::string > *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (bool)std_vector_Sl_std_string_Sg__Contains(arg1,(std::string const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorString_IndexOf(void * jarg1, char * jarg2) { int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string *arg2 = 0 ; int result;
  arg1 = (std::vector< std::string > *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (int)std_vector_Sl_std_string_Sg__IndexOf(arg1,(std::string const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorString_LastIndexOf(void * jarg1, char * jarg2) { int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string *arg2 = 0 ; int result;
  arg1 = (std::vector< std::string > *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (int)std_vector_Sl_std_string_Sg__LastIndexOf(arg1,(std::string const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorString_Remove(void * jarg1, char * jarg2) { unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (std::vector< std::string > *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (bool)std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorString(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; arg1 = (std::vector< std::string > *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_Clear(void * jarg1) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::vector3 const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorOBVector3_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  std::vector< OpenBabel::vector3 >::size_type result; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  result = ((std::vector< OpenBabel::vector3 > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorOBVector3_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  std::vector< OpenBabel::vector3 >::size_type result; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  result = ((std::vector< OpenBabel::vector3 > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  std::vector< OpenBabel::vector3 >::size_type arg2 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (std::vector< OpenBabel::vector3 >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBVector3__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::vector3 > *result = 0 ;
  result = (std::vector< OpenBabel::vector3 > *)new std::vector< OpenBabel::vector3 >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBVector3__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = 0 ; std::vector< OpenBabel::vector3 > *result = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::vector3 > *)new std::vector< OpenBabel::vector3 >((std::vector< OpenBabel::vector3 > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBVector3__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::vector3 > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::vector3 > *)new_std_vector_Sl_OpenBabel_vector3_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBVector3_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; OpenBabel::vector3 result;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_vector3_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBVector3_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  OpenBabel::vector3 *result = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::vector3 *) &std_vector_Sl_OpenBabel_vector3_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; OpenBabel::vector3 *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_vector3_Sg__setitem(arg1,arg2,(OpenBabel::vector3 const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  std::vector< OpenBabel::vector3 > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (std::vector< OpenBabel::vector3 > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_vector3_Sg__AddRange(arg1,(std::vector< OpenBabel::vector3 > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBVector3_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::vector3 > *result = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::vector3 > *)std_vector_Sl_OpenBabel_vector3_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; OpenBabel::vector3 *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_vector3_Sg__Insert(arg1,arg2,(OpenBabel::vector3 const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::vector3 > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_vector3_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::vector3 > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_vector3_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_vector3_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBVector3_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::vector3 *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::vector3 > *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::vector3 > *)std_vector_Sl_OpenBabel_vector3_Sg__Repeat((OpenBabel::vector3 const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  std_vector_Sl_OpenBabel_vector3_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_vector3_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBVector3_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::vector3 > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_vector3_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::vector3 > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorOBVector3(void * jarg1) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_Clear(void * jarg1) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  std::vector< OpenBabel::vector3 > *arg2 = 0 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (std::vector< OpenBabel::vector3 > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::vector3 > const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecOBVector3_size(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > >::size_type result;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  result = ((std::vector< std::vector< OpenBabel::vector3 > > const *)arg1)->size(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorVecOBVector3_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > >::size_type result;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  result = ((std::vector< std::vector< OpenBabel::vector3 > > const *)arg1)->capacity(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > >::size_type arg2 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (std::vector< std::vector< OpenBabel::vector3 > >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecOBVector3__SWIG_0() { void * jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *result = 0 ;
  result = (std::vector< std::vector< OpenBabel::vector3 > > *)new std::vector< std::vector< OpenBabel::vector3 > >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecOBVector3__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = 0 ; std::vector< std::vector< OpenBabel::vector3 > > *result = 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return 0; }  
  result = (std::vector< std::vector< OpenBabel::vector3 > > *)new std::vector< std::vector< OpenBabel::vector3 > >((std::vector< std::vector< OpenBabel::vector3 > > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorVecOBVector3__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< std::vector< OpenBabel::vector3 > > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< std::vector< OpenBabel::vector3 > > *)new_std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg___SWIG_2(arg1);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecOBVector3_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > result; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (int)jarg2;  try { result = std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new std::vector< OpenBabel::vector3 >((const std::vector< OpenBabel::vector3 > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecOBVector3_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > *result = 0 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::vector3 > *) &std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > *arg3 = 0 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::vector3 > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__setitem(arg1,arg2,(std::vector< OpenBabel::vector3 > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg2 = 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return ; }  
  std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__AddRange(arg1,(std::vector< std::vector< OpenBabel::vector3 > > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecOBVector3_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  int arg3 ; std::vector< std::vector< OpenBabel::vector3 > > *result = 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< std::vector< OpenBabel::vector3 > > *)std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__GetRange(arg1,arg2,arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 > *arg3 = 0 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::vector3 > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Insert(arg1,arg2,(std::vector< OpenBabel::vector3 > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg3 = 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< OpenBabel::vector3 > > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  int arg3 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorVecOBVector3_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = 0 ; int arg2 ; std::vector< std::vector< OpenBabel::vector3 > > *result = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 > const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< std::vector< OpenBabel::vector3 > > *)std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Repeat((std::vector< OpenBabel::vector3 > const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  int arg3 ; arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorVecOBVector3_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ; int arg2 ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg3 = 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_std_vector_Sl_OpenBabel_vector3_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< OpenBabel::vector3 > > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorVecOBVector3(void * jarg1) {
  std::vector< std::vector< OpenBabel::vector3 > > *arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *) 0 ;
  arg1 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_Clear(void * jarg1) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  OpenBabel::OBExternalBond *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (OpenBabel::OBExternalBond *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBExternalBond const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBExternalBond const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorOBExternalBond_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  std::vector< OpenBabel::OBExternalBond >::size_type result; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  result = ((std::vector< OpenBabel::OBExternalBond > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorOBExternalBond_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  std::vector< OpenBabel::OBExternalBond >::size_type result; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  result = ((std::vector< OpenBabel::OBExternalBond > const *)arg1)->capacity(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  std::vector< OpenBabel::OBExternalBond >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBExternalBond >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBExternalBond__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBExternalBond > *result = 0 ;
  result = (std::vector< OpenBabel::OBExternalBond > *)new std::vector< OpenBabel::OBExternalBond >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBExternalBond__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = 0 ; std::vector< OpenBabel::OBExternalBond > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBExternalBond > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBExternalBond > *)new std::vector< OpenBabel::OBExternalBond >((std::vector< OpenBabel::OBExternalBond > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorOBExternalBond__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBExternalBond > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBExternalBond > *)new_std_vector_Sl_OpenBabel_OBExternalBond_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBExternalBond_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  OpenBabel::OBExternalBond result; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_OBExternalBond_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBExternalBond((const OpenBabel::OBExternalBond &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBExternalBond_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  OpenBabel::OBExternalBond *result = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBExternalBond *) &std_vector_Sl_OpenBabel_OBExternalBond_Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  OpenBabel::OBExternalBond *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBExternalBond *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBExternalBond const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBExternalBond_Sg__setitem(arg1,arg2,(OpenBabel::OBExternalBond const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  std::vector< OpenBabel::OBExternalBond > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBExternalBond > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBExternalBond > const & type is null", 0);
    return ; }  
  std_vector_Sl_OpenBabel_OBExternalBond_Sg__AddRange(arg1,(std::vector< OpenBabel::OBExternalBond > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBExternalBond_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBExternalBond > *result = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBExternalBond > *)std_vector_Sl_OpenBabel_OBExternalBond_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  OpenBabel::OBExternalBond *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBExternalBond *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBExternalBond const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBExternalBond_Sg__Insert(arg1,arg2,(OpenBabel::OBExternalBond const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBExternalBond > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBExternalBond > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBExternalBond > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBExternalBond_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBExternalBond > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBExternalBond_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBExternalBond_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorOBExternalBond_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBExternalBond *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBExternalBond > *result = 0 ;
  arg1 = (OpenBabel::OBExternalBond *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBExternalBond const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBExternalBond > *)std_vector_Sl_OpenBabel_OBExternalBond_Sg__Repeat((OpenBabel::OBExternalBond const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  std_vector_Sl_OpenBabel_OBExternalBond_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBExternalBond_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorOBExternalBond_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBExternalBond > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBExternalBond > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBExternalBond > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBExternalBond_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBExternalBond > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorOBExternalBond(void * jarg1) {
  std::vector< OpenBabel::OBExternalBond > *arg1 = (std::vector< OpenBabel::OBExternalBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBExternalBond > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_Clear(void * jarg1) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBMol const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorMol_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  std::vector< OpenBabel::OBMol >::size_type result; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; 
  result = ((std::vector< OpenBabel::OBMol > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorMol_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  std::vector< OpenBabel::OBMol >::size_type result; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; 
  result = ((std::vector< OpenBabel::OBMol > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  std::vector< OpenBabel::OBMol >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBMol >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorMol__SWIG_0() { void * jresult ; std::vector< OpenBabel::OBMol > *result = 0 ;
  result = (std::vector< OpenBabel::OBMol > *)new std::vector< OpenBabel::OBMol >(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorMol__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = 0 ; std::vector< OpenBabel::OBMol > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBMol > *)new std::vector< OpenBabel::OBMol >((std::vector< OpenBabel::OBMol > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorMol__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBMol > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBMol > *)new_std_vector_Sl_OpenBabel_OBMol_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorMol_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; OpenBabel::OBMol result;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_OBMol_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBMol((const OpenBabel::OBMol &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorMol_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBMol *) &std_vector_Sl_OpenBabel_OBMol_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; OpenBabel::OBMol *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBMol *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBMol_Sg__setitem(arg1,arg2,(OpenBabel::OBMol const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; std::vector< OpenBabel::OBMol > *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (std::vector< OpenBabel::OBMol > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBMol_Sg__AddRange(arg1,(std::vector< OpenBabel::OBMol > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorMol_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBMol > *result = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBMol > *)std_vector_Sl_OpenBabel_OBMol_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; OpenBabel::OBMol *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBMol *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBMol_Sg__Insert(arg1,arg2,(OpenBabel::OBMol const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBMol > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBMol > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol > const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBMol_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBMol > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBMol_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBMol_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorMol_Repeat(void * jarg1, int jarg2) { void * jresult ; OpenBabel::OBMol *arg1 = 0 ;
  int arg2 ; std::vector< OpenBabel::OBMol > *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBMol > *)std_vector_Sl_OpenBabel_OBMol_Sg__Repeat((OpenBabel::OBMol const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  std_vector_Sl_OpenBabel_OBMol_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBMol_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorMol_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBMol > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBMol > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol > const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBMol_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBMol > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorMol(void * jarg1) {
  std::vector< OpenBabel::OBMol > *arg1 = (std::vector< OpenBabel::OBMol > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_Clear(void * jarg1) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; OpenBabel::OBBond *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBond const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBBond const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorBond_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  std::vector< OpenBabel::OBBond >::size_type result; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  result = ((std::vector< OpenBabel::OBBond > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorBond_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  std::vector< OpenBabel::OBBond >::size_type result; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  result = ((std::vector< OpenBabel::OBBond > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  std::vector< OpenBabel::OBBond >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBBond >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorBond__SWIG_0() { void * jresult ; std::vector< OpenBabel::OBBond > *result = 0 ;
  result = (std::vector< OpenBabel::OBBond > *)new std::vector< OpenBabel::OBBond >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorBond__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = 0 ; std::vector< OpenBabel::OBBond > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBBond > *)new std::vector< OpenBabel::OBBond >((std::vector< OpenBabel::OBBond > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorBond__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBBond > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBBond > *)new_std_vector_Sl_OpenBabel_OBBond_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorBond_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; OpenBabel::OBBond result;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_OBBond_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBBond((const OpenBabel::OBBond &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorBond_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBBond *) &std_vector_Sl_OpenBabel_OBBond_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; OpenBabel::OBBond *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBBond *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBond const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBBond_Sg__setitem(arg1,arg2,(OpenBabel::OBBond const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; std::vector< OpenBabel::OBBond > *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (std::vector< OpenBabel::OBBond > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBBond_Sg__AddRange(arg1,(std::vector< OpenBabel::OBBond > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorBond_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBBond > *result = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBBond > *)std_vector_Sl_OpenBabel_OBBond_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; OpenBabel::OBBond *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBBond *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBond const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBBond_Sg__Insert(arg1,arg2,(OpenBabel::OBBond const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBBond > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBBond > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBBond_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBBond > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBBond_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorBond_Repeat(void * jarg1, int jarg2) { void * jresult ; OpenBabel::OBBond *arg1 = 0 ;
  int arg2 ; std::vector< OpenBabel::OBBond > *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBond const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBBond > *)std_vector_Sl_OpenBabel_OBBond_Sg__Repeat((OpenBabel::OBBond const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  std_vector_Sl_OpenBabel_OBBond_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorBond_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBBond > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBBond > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond > const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBBond_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBBond > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorBond(void * jarg1) {
  std::vector< OpenBabel::OBBond > *arg1 = (std::vector< OpenBabel::OBBond > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_Clear(void * jarg1) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; OpenBabel::OBResidue *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBResidue const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorResidue_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  std::vector< OpenBabel::OBResidue >::size_type result; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  result = ((std::vector< OpenBabel::OBResidue > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorResidue_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  std::vector< OpenBabel::OBResidue >::size_type result; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  result = ((std::vector< OpenBabel::OBResidue > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  std::vector< OpenBabel::OBResidue >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBResidue >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorResidue__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBResidue > *result = 0 ;
  result = (std::vector< OpenBabel::OBResidue > *)new std::vector< OpenBabel::OBResidue >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorResidue__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = 0 ; std::vector< OpenBabel::OBResidue > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBResidue > *)new std::vector< OpenBabel::OBResidue >((std::vector< OpenBabel::OBResidue > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorResidue__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBResidue > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBResidue > *)new_std_vector_Sl_OpenBabel_OBResidue_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorResidue_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  OpenBabel::OBResidue result; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_OBResidue_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBResidue((const OpenBabel::OBResidue &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorResidue_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  OpenBabel::OBResidue *result = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBResidue *) &std_vector_Sl_OpenBabel_OBResidue_Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  OpenBabel::OBResidue *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBResidue *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBResidue_Sg__setitem(arg1,arg2,(OpenBabel::OBResidue const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  std::vector< OpenBabel::OBResidue > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBResidue > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBResidue_Sg__AddRange(arg1,(std::vector< OpenBabel::OBResidue > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorResidue_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBResidue > *result = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBResidue > *)std_vector_Sl_OpenBabel_OBResidue_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  OpenBabel::OBResidue *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBResidue *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBResidue_Sg__Insert(arg1,arg2,(OpenBabel::OBResidue const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBResidue > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBResidue > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBResidue_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBResidue > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBResidue_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBResidue_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorResidue_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBResidue *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBResidue > *result = 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBResidue > *)std_vector_Sl_OpenBabel_OBResidue_Sg__Repeat((OpenBabel::OBResidue const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  std_vector_Sl_OpenBabel_OBResidue_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBResidue_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorResidue_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBResidue > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBResidue > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBResidue_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBResidue > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorResidue(void * jarg1) {
  std::vector< OpenBabel::OBResidue > *arg1 = (std::vector< OpenBabel::OBResidue > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_Clear(void * jarg1) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; OpenBabel::OBRing *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (OpenBabel::OBRing *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRing const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBRing const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorRing_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  std::vector< OpenBabel::OBRing >::size_type result; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRing > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorRing_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  std::vector< OpenBabel::OBRing >::size_type result; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRing > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  std::vector< OpenBabel::OBRing >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorRing__SWIG_0() { void * jresult ; std::vector< OpenBabel::OBRing > *result = 0 ;
  result = (std::vector< OpenBabel::OBRing > *)new std::vector< OpenBabel::OBRing >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorRing__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = 0 ; std::vector< OpenBabel::OBRing > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBRing > *)new std::vector< OpenBabel::OBRing >((std::vector< OpenBabel::OBRing > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorRing__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBRing > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBRing > *)new_std_vector_Sl_OpenBabel_OBRing_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorRing_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; OpenBabel::OBRing result;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  try {
    result = std_vector_Sl_OpenBabel_OBRing_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBRing((const OpenBabel::OBRing &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorRing_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; OpenBabel::OBRing *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBRing *) &std_vector_Sl_OpenBabel_OBRing_Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; OpenBabel::OBRing *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBRing *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRing const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBRing_Sg__setitem(arg1,arg2,(OpenBabel::OBRing const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; std::vector< OpenBabel::OBRing > *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (std::vector< OpenBabel::OBRing > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBRing_Sg__AddRange(arg1,(std::vector< OpenBabel::OBRing > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorRing_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBRing > *result = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBRing > *)std_vector_Sl_OpenBabel_OBRing_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; OpenBabel::OBRing *arg3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBRing *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRing const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBRing_Sg__Insert(arg1,arg2,(OpenBabel::OBRing const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRing > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRing > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBRing_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBRing > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBRing_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorRing_Repeat(void * jarg1, int jarg2) { void * jresult ; OpenBabel::OBRing *arg1 = 0 ;
  int arg2 ; std::vector< OpenBabel::OBRing > *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRing const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBRing > *)std_vector_Sl_OpenBabel_OBRing_Sg__Repeat((OpenBabel::OBRing const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  std_vector_Sl_OpenBabel_OBRing_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorRing_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRing > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRing > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing > const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBRing_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBRing > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorRing(void * jarg1) {
  std::vector< OpenBabel::OBRing > *arg1 = (std::vector< OpenBabel::OBRing > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_Clear(void * jarg1) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; OpenBabel::OBTorsion *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (OpenBabel::OBTorsion *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion const & type is null", 0);
    return ; }   (arg1)->push_back((OpenBabel::OBTorsion const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorTorsion_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  std::vector< OpenBabel::OBTorsion >::size_type result; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1; 
  result = ((std::vector< OpenBabel::OBTorsion > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorTorsion_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  std::vector< OpenBabel::OBTorsion >::size_type result; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1; 
  result = ((std::vector< OpenBabel::OBTorsion > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  std::vector< OpenBabel::OBTorsion >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBTorsion >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorTorsion__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBTorsion > *result = 0 ;
  result = (std::vector< OpenBabel::OBTorsion > *)new std::vector< OpenBabel::OBTorsion >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorTorsion__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = 0 ; std::vector< OpenBabel::OBTorsion > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBTorsion > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBTorsion > *)new std::vector< OpenBabel::OBTorsion >((std::vector< OpenBabel::OBTorsion > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorTorsion__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBTorsion > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBTorsion > *)new_std_vector_Sl_OpenBabel_OBTorsion_Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorTorsion_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  SwigValueWrapper< OpenBabel::OBTorsion > result; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  try { result = std_vector_Sl_OpenBabel_OBTorsion_Sg__getitemcopy(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = new OpenBabel::OBTorsion((const OpenBabel::OBTorsion &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorTorsion_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  OpenBabel::OBTorsion *result = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBTorsion *) &std_vector_Sl_OpenBabel_OBTorsion_Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  OpenBabel::OBTorsion *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBTorsion *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBTorsion_Sg__setitem(arg1,arg2,(OpenBabel::OBTorsion const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  std::vector< OpenBabel::OBTorsion > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBTorsion > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBTorsion > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBTorsion_Sg__AddRange(arg1,(std::vector< OpenBabel::OBTorsion > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorTorsion_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBTorsion > *result = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBTorsion > *)std_vector_Sl_OpenBabel_OBTorsion_Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  OpenBabel::OBTorsion *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBTorsion *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion const & type is null", 0);
    return ; }   try { std_vector_Sl_OpenBabel_OBTorsion_Sg__Insert(arg1,arg2,(OpenBabel::OBTorsion const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBTorsion > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBTorsion > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBTorsion > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBTorsion_Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBTorsion > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBTorsion_Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBTorsion_Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorTorsion_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBTorsion *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBTorsion > *result = 0 ;
  arg1 = (OpenBabel::OBTorsion *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion const & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBTorsion > *)std_vector_Sl_OpenBabel_OBTorsion_Sg__Repeat((OpenBabel::OBTorsion const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  std_vector_Sl_OpenBabel_OBTorsion_Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBTorsion_Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorTorsion_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBTorsion > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBTorsion > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBTorsion > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBTorsion_Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBTorsion > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorTorsion(void * jarg1) {
  std::vector< OpenBabel::OBTorsion > *arg1 = (std::vector< OpenBabel::OBTorsion > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBTorsion > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_Clear(void * jarg1) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; OpenBabel::OBRing **arg2 = 0 ;
  OpenBabel::OBRing *temp2 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  temp2 = (OpenBabel::OBRing *)jarg2;
  arg2 = (OpenBabel::OBRing **)&temp2;  (arg1)->push_back((OpenBabel::OBRing *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpRing_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  std::vector< OpenBabel::OBRing * >::size_type result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRing * > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpRing_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  std::vector< OpenBabel::OBRing * >::size_type result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRing * > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  std::vector< OpenBabel::OBRing * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRing__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBRing * > *result = 0 ;
  result = (std::vector< OpenBabel::OBRing * > *)new std::vector< OpenBabel::OBRing * >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRing__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBRing * > *)new std::vector< OpenBabel::OBRing * >((std::vector< OpenBabel::OBRing * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRing__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBRing * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBRing * > *)new_std_vector_Sl_OpenBabel_OBRing_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRing_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  OpenBabel::OBRing *result = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBRing *)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRing_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  OpenBabel::OBRing **result = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBRing **) &std_vector_Sl_OpenBabel_OBRing_Sm__Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  OpenBabel::OBRing **arg3 = 0 ; OpenBabel::OBRing *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBRing *)jarg3; arg3 = (OpenBabel::OBRing **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBRing *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  std::vector< OpenBabel::OBRing * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBRing_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBRing * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRing_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBRing * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBRing * > *)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  OpenBabel::OBRing **arg3 = 0 ; OpenBabel::OBRing *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBRing *)jarg3; arg3 = (OpenBabel::OBRing **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBRing *const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRing * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRing * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBRing * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRing_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBRing **arg1 = 0 ; int arg2 ; OpenBabel::OBRing *temp1 = 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  temp1 = (OpenBabel::OBRing *)jarg1; arg1 = (OpenBabel::OBRing **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBRing * > *)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Repeat((OpenBabel::OBRing *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRing_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRing * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRing * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBRing_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBRing * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpRing_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; OpenBabel::OBRing **arg2 = 0 ;
  OpenBabel::OBRing *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  temp2 = (OpenBabel::OBRing *)jarg2; arg2 = (OpenBabel::OBRing **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Contains(arg1,(OpenBabel::OBRing *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpRing_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; OpenBabel::OBRing **arg2 = 0 ;
  OpenBabel::OBRing *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  temp2 = (OpenBabel::OBRing *)jarg2; arg2 = (OpenBabel::OBRing **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__IndexOf(arg1,(OpenBabel::OBRing *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpRing_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; OpenBabel::OBRing **arg2 = 0 ;
  OpenBabel::OBRing *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  temp2 = (OpenBabel::OBRing *)jarg2; arg2 = (OpenBabel::OBRing **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBRing *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpRing_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ; OpenBabel::OBRing **arg2 = 0 ;
  OpenBabel::OBRing *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  temp2 = (OpenBabel::OBRing *)jarg2; arg2 = (OpenBabel::OBRing **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBRing_Sm__Sg__Remove(arg1,(OpenBabel::OBRing *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpRing(void * jarg1) {
  std::vector< OpenBabel::OBRing * > *arg1 = (std::vector< OpenBabel::OBRing * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_Clear(void * jarg1) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  OpenBabel::OBGenericData **arg2 = 0 ; OpenBabel::OBGenericData *temp2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  temp2 = (OpenBabel::OBGenericData *)jarg2;
  arg2 = (OpenBabel::OBGenericData **)&temp2;  (arg1)->push_back((OpenBabel::OBGenericData *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpData_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  std::vector< OpenBabel::OBGenericData * >::size_type result; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBGenericData * > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpData_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  std::vector< OpenBabel::OBGenericData * >::size_type result; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBGenericData * > const *)arg1)->capacity(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  std::vector< OpenBabel::OBGenericData * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBGenericData * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpData__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  result = (std::vector< OpenBabel::OBGenericData * > *)new std::vector< OpenBabel::OBGenericData * >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpData__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBGenericData * > *)new std::vector< OpenBabel::OBGenericData * >((std::vector< OpenBabel::OBGenericData * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpData__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBGenericData * > *)new_std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpData_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  OpenBabel::OBGenericData *result = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBGenericData *)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpData_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  OpenBabel::OBGenericData **result = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBGenericData **) &std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  OpenBabel::OBGenericData **arg3 = 0 ; OpenBabel::OBGenericData *temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBGenericData *)jarg3;
  arg3 = (OpenBabel::OBGenericData **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBGenericData *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBGenericData * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > const & type is null", 0);
    return ; }  
  std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBGenericData * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpData_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBGenericData * > *)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__GetRange(arg1,arg2,arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  OpenBabel::OBGenericData **arg3 = 0 ; OpenBabel::OBGenericData *temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBGenericData *)jarg3;
  arg3 = (OpenBabel::OBGenericData **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBGenericData *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBGenericData * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBGenericData * > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpData_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBGenericData **arg1 = 0 ; int arg2 ; OpenBabel::OBGenericData *temp1 = 0 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; temp1 = (OpenBabel::OBGenericData *)jarg1;
  arg1 = (OpenBabel::OBGenericData **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBGenericData * > *)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Repeat((OpenBabel::OBGenericData *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpData_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBGenericData * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBGenericData * > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpData_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  OpenBabel::OBGenericData **arg2 = 0 ; OpenBabel::OBGenericData *temp2 = 0 ; bool result;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  temp2 = (OpenBabel::OBGenericData *)jarg2;
  arg2 = (OpenBabel::OBGenericData **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Contains(arg1,(OpenBabel::OBGenericData *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpData_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  OpenBabel::OBGenericData **arg2 = 0 ; OpenBabel::OBGenericData *temp2 = 0 ; int result;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  temp2 = (OpenBabel::OBGenericData *)jarg2;
  arg2 = (OpenBabel::OBGenericData **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__IndexOf(arg1,(OpenBabel::OBGenericData *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpData_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  OpenBabel::OBGenericData **arg2 = 0 ; OpenBabel::OBGenericData *temp2 = 0 ; int result;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  temp2 = (OpenBabel::OBGenericData *)jarg2;
  arg2 = (OpenBabel::OBGenericData **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBGenericData *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpData_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  OpenBabel::OBGenericData **arg2 = 0 ; OpenBabel::OBGenericData *temp2 = 0 ; bool result;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  temp2 = (OpenBabel::OBGenericData *)jarg2;
  arg2 = (OpenBabel::OBGenericData **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__Remove(arg1,(OpenBabel::OBGenericData *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpData(void * jarg1) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_Clear(void * jarg1) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  OpenBabel::OBInternalCoord **arg2 = 0 ; OpenBabel::OBInternalCoord *temp2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  temp2 = (OpenBabel::OBInternalCoord *)jarg2;
  arg2 = (OpenBabel::OBInternalCoord **)&temp2;  (arg1)->push_back((OpenBabel::OBInternalCoord *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpInternalCoord_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  std::vector< OpenBabel::OBInternalCoord * >::size_type result; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBInternalCoord * > const *)arg1)->size(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpInternalCoord_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  std::vector< OpenBabel::OBInternalCoord * >::size_type result; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBInternalCoord * > const *)arg1)->capacity(); jresult = (unsigned long)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  std::vector< OpenBabel::OBInternalCoord * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBInternalCoord * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpInternalCoord__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *result = 0 ;
  result = (std::vector< OpenBabel::OBInternalCoord * > *)new std::vector< OpenBabel::OBInternalCoord * >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpInternalCoord__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = 0 ; std::vector< OpenBabel::OBInternalCoord * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBInternalCoord * > *)new std::vector< OpenBabel::OBInternalCoord * >((std::vector< OpenBabel::OBInternalCoord * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpInternalCoord__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBInternalCoord * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBInternalCoord * > *)new_std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpInternalCoord_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  OpenBabel::OBInternalCoord *result = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2; 
  try { result = (OpenBabel::OBInternalCoord *)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpInternalCoord_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  OpenBabel::OBInternalCoord **result = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2; 
  try { result = (OpenBabel::OBInternalCoord **) &std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  OpenBabel::OBInternalCoord **arg3 = 0 ; OpenBabel::OBInternalCoord *temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBInternalCoord *)jarg3;
  arg3 = (OpenBabel::OBInternalCoord **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBInternalCoord *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  std::vector< OpenBabel::OBInternalCoord * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > const & type is null", 0);
    return ; }  
  std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBInternalCoord * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpInternalCoord_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBInternalCoord * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBInternalCoord * > *)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__GetRange(arg1,arg2,arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  OpenBabel::OBInternalCoord **arg3 = 0 ; OpenBabel::OBInternalCoord *temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBInternalCoord *)jarg3;
  arg3 = (OpenBabel::OBInternalCoord **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBInternalCoord *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBInternalCoord * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBInternalCoord * > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpInternalCoord_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBInternalCoord **arg1 = 0 ; int arg2 ; OpenBabel::OBInternalCoord *temp1 = 0 ;
  std::vector< OpenBabel::OBInternalCoord * > *result = 0 ; temp1 = (OpenBabel::OBInternalCoord *)jarg1;
  arg1 = (OpenBabel::OBInternalCoord **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBInternalCoord * > *)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Repeat((OpenBabel::OBInternalCoord *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpInternalCoord_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBInternalCoord * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBInternalCoord * > const &)*arg3);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpInternalCoord_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  OpenBabel::OBInternalCoord **arg2 = 0 ; OpenBabel::OBInternalCoord *temp2 = 0 ; bool result;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  temp2 = (OpenBabel::OBInternalCoord *)jarg2;
  arg2 = (OpenBabel::OBInternalCoord **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Contains(arg1,(OpenBabel::OBInternalCoord *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpInternalCoord_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  OpenBabel::OBInternalCoord **arg2 = 0 ; OpenBabel::OBInternalCoord *temp2 = 0 ; int result;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  temp2 = (OpenBabel::OBInternalCoord *)jarg2;
  arg2 = (OpenBabel::OBInternalCoord **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__IndexOf(arg1,(OpenBabel::OBInternalCoord *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpInternalCoord_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  OpenBabel::OBInternalCoord **arg2 = 0 ; OpenBabel::OBInternalCoord *temp2 = 0 ; int result;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  temp2 = (OpenBabel::OBInternalCoord *)jarg2;
  arg2 = (OpenBabel::OBInternalCoord **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBInternalCoord *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpInternalCoord_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  OpenBabel::OBInternalCoord **arg2 = 0 ; OpenBabel::OBInternalCoord *temp2 = 0 ; bool result;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  temp2 = (OpenBabel::OBInternalCoord *)jarg2;
  arg2 = (OpenBabel::OBInternalCoord **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBInternalCoord_Sm__Sg__Remove(arg1,(OpenBabel::OBInternalCoord *const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpInternalCoord(void * jarg1) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = (std::vector< OpenBabel::OBInternalCoord * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_Clear(void * jarg1) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; OpenBabel::OBAtom **arg2 = 0 ;
  OpenBabel::OBAtom *temp2 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  temp2 = (OpenBabel::OBAtom *)jarg2;
  arg2 = (OpenBabel::OBAtom **)&temp2;  (arg1)->push_back((OpenBabel::OBAtom *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpAtom_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  std::vector< OpenBabel::OBAtom * >::size_type result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBAtom * > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpAtom_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  std::vector< OpenBabel::OBAtom * >::size_type result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBAtom * > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  std::vector< OpenBabel::OBAtom * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpAtom__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBAtom * > *result = 0 ;
  result = (std::vector< OpenBabel::OBAtom * > *)new std::vector< OpenBabel::OBAtom * >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpAtom__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = 0 ; std::vector< OpenBabel::OBAtom * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBAtom * > *)new std::vector< OpenBabel::OBAtom * >((std::vector< OpenBabel::OBAtom * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpAtom__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBAtom * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBAtom * > *)new_std_vector_Sl_OpenBabel_OBAtom_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpAtom_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBAtom *)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpAtom_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  OpenBabel::OBAtom **result = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBAtom **) &std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  OpenBabel::OBAtom **arg3 = 0 ; OpenBabel::OBAtom *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBAtom *)jarg3; arg3 = (OpenBabel::OBAtom **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBAtom *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  std::vector< OpenBabel::OBAtom * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBAtom * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpAtom_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBAtom * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBAtom * > *)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  OpenBabel::OBAtom **arg3 = 0 ; OpenBabel::OBAtom *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBAtom *)jarg3; arg3 = (OpenBabel::OBAtom **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBAtom *const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBAtom * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBAtom * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBAtom * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpAtom_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBAtom **arg1 = 0 ; int arg2 ; OpenBabel::OBAtom *temp1 = 0 ; std::vector< OpenBabel::OBAtom * > *result = 0 ;
  temp1 = (OpenBabel::OBAtom *)jarg1; arg1 = (OpenBabel::OBAtom **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBAtom * > *)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Repeat((OpenBabel::OBAtom *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpAtom_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBAtom * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBAtom * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBAtom * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpAtom_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; OpenBabel::OBAtom **arg2 = 0 ;
  OpenBabel::OBAtom *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  temp2 = (OpenBabel::OBAtom *)jarg2; arg2 = (OpenBabel::OBAtom **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Contains(arg1,(OpenBabel::OBAtom *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpAtom_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; OpenBabel::OBAtom **arg2 = 0 ;
  OpenBabel::OBAtom *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  temp2 = (OpenBabel::OBAtom *)jarg2; arg2 = (OpenBabel::OBAtom **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__IndexOf(arg1,(OpenBabel::OBAtom *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpAtom_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; OpenBabel::OBAtom **arg2 = 0 ;
  OpenBabel::OBAtom *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  temp2 = (OpenBabel::OBAtom *)jarg2; arg2 = (OpenBabel::OBAtom **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBAtom *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpAtom_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ; OpenBabel::OBAtom **arg2 = 0 ;
  OpenBabel::OBAtom *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1; 
  temp2 = (OpenBabel::OBAtom *)jarg2; arg2 = (OpenBabel::OBAtom **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBAtom_Sm__Sg__Remove(arg1,(OpenBabel::OBAtom *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpAtom(void * jarg1) {
  std::vector< OpenBabel::OBAtom * > *arg1 = (std::vector< OpenBabel::OBAtom * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBAtom * > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_Clear(void * jarg1) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; OpenBabel::OBBond **arg2 = 0 ;
  OpenBabel::OBBond *temp2 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  temp2 = (OpenBabel::OBBond *)jarg2;
  arg2 = (OpenBabel::OBBond **)&temp2;  (arg1)->push_back((OpenBabel::OBBond *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpBond_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  std::vector< OpenBabel::OBBond * >::size_type result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBBond * > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpBond_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  std::vector< OpenBabel::OBBond * >::size_type result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBBond * > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  std::vector< OpenBabel::OBBond * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBBond * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpBond__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBBond * > *result = 0 ;
  result = (std::vector< OpenBabel::OBBond * > *)new std::vector< OpenBabel::OBBond * >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpBond__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = 0 ; std::vector< OpenBabel::OBBond * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBBond * > *)new std::vector< OpenBabel::OBBond * >((std::vector< OpenBabel::OBBond * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpBond__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBBond * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBBond * > *)new_std_vector_Sl_OpenBabel_OBBond_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpBond_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBBond *)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpBond_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  OpenBabel::OBBond **result = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBBond **) &std_vector_Sl_OpenBabel_OBBond_Sm__Sg__getitem(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  OpenBabel::OBBond **arg3 = 0 ; OpenBabel::OBBond *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBBond *)jarg3; arg3 = (OpenBabel::OBBond **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBBond *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  std::vector< OpenBabel::OBBond * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBBond * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond * > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBBond_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBBond * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpBond_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBBond * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBBond * > *)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  OpenBabel::OBBond **arg3 = 0 ; OpenBabel::OBBond *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBBond *)jarg3; arg3 = (OpenBabel::OBBond **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBBond *const &)*arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBBond * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBBond * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBBond * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpBond_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBBond **arg1 = 0 ; int arg2 ; OpenBabel::OBBond *temp1 = 0 ; std::vector< OpenBabel::OBBond * > *result = 0 ;
  temp1 = (OpenBabel::OBBond *)jarg1; arg1 = (OpenBabel::OBBond **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBBond * > *)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Repeat((OpenBabel::OBBond *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpBond_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBBond * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBBond * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBBond_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBBond * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpBond_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; OpenBabel::OBBond **arg2 = 0 ;
  OpenBabel::OBBond *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  temp2 = (OpenBabel::OBBond *)jarg2; arg2 = (OpenBabel::OBBond **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Contains(arg1,(OpenBabel::OBBond *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpBond_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; OpenBabel::OBBond **arg2 = 0 ;
  OpenBabel::OBBond *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  temp2 = (OpenBabel::OBBond *)jarg2; arg2 = (OpenBabel::OBBond **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__IndexOf(arg1,(OpenBabel::OBBond *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpBond_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; OpenBabel::OBBond **arg2 = 0 ;
  OpenBabel::OBBond *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  temp2 = (OpenBabel::OBBond *)jarg2; arg2 = (OpenBabel::OBBond **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBBond *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpBond_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ; OpenBabel::OBBond **arg2 = 0 ;
  OpenBabel::OBBond *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1; 
  temp2 = (OpenBabel::OBBond *)jarg2; arg2 = (OpenBabel::OBBond **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBBond_Sm__Sg__Remove(arg1,(OpenBabel::OBBond *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpBond(void * jarg1) {
  std::vector< OpenBabel::OBBond * > *arg1 = (std::vector< OpenBabel::OBBond * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBBond * > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_Clear(void * jarg1) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; OpenBabel::OBRotor **arg2 = 0 ;
  OpenBabel::OBRotor *temp2 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  temp2 = (OpenBabel::OBRotor *)jarg2;
  arg2 = (OpenBabel::OBRotor **)&temp2;  (arg1)->push_back((OpenBabel::OBRotor *const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpRotor_size(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  std::vector< OpenBabel::OBRotor * >::size_type result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRotor * > const *)arg1)->size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_VectorpRotor_capacity(void * jarg1) { unsigned long jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  std::vector< OpenBabel::OBRotor * >::size_type result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  result = ((std::vector< OpenBabel::OBRotor * > const *)arg1)->capacity(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  std::vector< OpenBabel::OBRotor * >::size_type arg2 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRotor * >::size_type)jarg2;  (arg1)->reserve(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRotor__SWIG_0() { void * jresult ;
  std::vector< OpenBabel::OBRotor * > *result = 0 ;
  result = (std::vector< OpenBabel::OBRotor * > *)new std::vector< OpenBabel::OBRotor * >(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRotor__SWIG_1(void * jarg1) { void * jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = 0 ; std::vector< OpenBabel::OBRotor * > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRotor * > const & type is null", 0);
    return 0; }  
  result = (std::vector< OpenBabel::OBRotor * > *)new std::vector< OpenBabel::OBRotor * >((std::vector< OpenBabel::OBRotor * > const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_VectorpRotor__SWIG_2(int jarg1) { void * jresult ; int arg1 ;
  std::vector< OpenBabel::OBRotor * > *result = 0 ; arg1 = (int)jarg1;  try {
    result = (std::vector< OpenBabel::OBRotor * > *)new_std_vector_Sl_OpenBabel_OBRotor_Sm__Sg___SWIG_2(arg1);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRotor_getitemcopy(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  OpenBabel::OBRotor *result = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBRotor *)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__getitemcopy(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRotor_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  OpenBabel::OBRotor **result = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2;  try {
    result = (OpenBabel::OBRotor **) &std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__getitem(arg1,arg2);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  OpenBabel::OBRotor **arg3 = 0 ; OpenBabel::OBRotor *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBRotor *)jarg3; arg3 = (OpenBabel::OBRotor **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__setitem(arg1,arg2,(OpenBabel::OBRotor *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_AddRange(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  std::vector< OpenBabel::OBRotor * > *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRotor * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRotor * > const & type is null", 0);
    return ; }   std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__AddRange(arg1,(std::vector< OpenBabel::OBRotor * > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRotor_GetRange(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ; int arg3 ;
  std::vector< OpenBabel::OBRotor * > *result = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  try {
    result = (std::vector< OpenBabel::OBRotor * > *)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__GetRange(arg1,arg2,arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  OpenBabel::OBRotor **arg3 = 0 ; OpenBabel::OBRotor *temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (OpenBabel::OBRotor *)jarg3; arg3 = (OpenBabel::OBRotor **)&temp3;  try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Insert(arg1,arg2,(OpenBabel::OBRotor *const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRotor * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRotor * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRotor * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__InsertRange(arg1,arg2,(std::vector< OpenBabel::OBRotor * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_RemoveAt(void * jarg1, int jarg2) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2;  try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__RemoveAt(arg1,arg2);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__RemoveRange(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_VectorpRotor_Repeat(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBRotor **arg1 = 0 ; int arg2 ; OpenBabel::OBRotor *temp1 = 0 ; std::vector< OpenBabel::OBRotor * > *result = 0 ;
  temp1 = (OpenBabel::OBRotor *)jarg1; arg1 = (OpenBabel::OBRotor **)&temp1;  arg2 = (int)jarg2;  try {
    result = (std::vector< OpenBabel::OBRotor * > *)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Repeat((OpenBabel::OBRotor *const &)*arg1,arg2);}
   catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_Reverse__SWIG_0(void * jarg1) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Reverse__SWIG_0(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ; int arg3 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);}  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; } 
  catch(std::invalid_argument &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ; }  }
SWIGEXPORT void SWIGSTDCALL CSharp_VectorpRotor_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBRotor * > *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBRotor * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRotor * > const & type is null", 0);
    return ; }   try {
    std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__SetRange(arg1,arg2,(std::vector< OpenBabel::OBRotor * > const &)*arg3);} 
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return ; }  }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpRotor_Contains(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; OpenBabel::OBRotor **arg2 = 0 ;
  OpenBabel::OBRotor *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  temp2 = (OpenBabel::OBRotor *)jarg2; arg2 = (OpenBabel::OBRotor **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Contains(arg1,(OpenBabel::OBRotor *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpRotor_IndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; OpenBabel::OBRotor **arg2 = 0 ;
  OpenBabel::OBRotor *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  temp2 = (OpenBabel::OBRotor *)jarg2; arg2 = (OpenBabel::OBRotor **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__IndexOf(arg1,(OpenBabel::OBRotor *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorpRotor_LastIndexOf(void * jarg1, void * jarg2) { int jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; OpenBabel::OBRotor **arg2 = 0 ;
  OpenBabel::OBRotor *temp2 = 0 ; int result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  temp2 = (OpenBabel::OBRotor *)jarg2; arg2 = (OpenBabel::OBRotor **)&temp2; 
  result = (int)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__LastIndexOf(arg1,(OpenBabel::OBRotor *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_VectorpRotor_Remove(void * jarg1, void * jarg2) { unsigned int jresult ;
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ; OpenBabel::OBRotor **arg2 = 0 ;
  OpenBabel::OBRotor *temp2 = 0 ; bool result; arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1; 
  temp2 = (OpenBabel::OBRotor *)jarg2; arg2 = (OpenBabel::OBRotor **)&temp2; 
  result = (bool)std_vector_Sl_OpenBabel_OBRotor_Sm__Sg__Remove(arg1,(OpenBabel::OBRotor *const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_VectorpRotor(void * jarg1) {
  std::vector< OpenBabel::OBRotor * > *arg1 = (std::vector< OpenBabel::OBRotor * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBRotor * > *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGlobalDataBase() { void * jresult ; OpenBabel::OBGlobalDataBase *result = 0 ;
  result = (OpenBabel::OBGlobalDataBase *)new OpenBabel::OBGlobalDataBase(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBGlobalDataBase(void * jarg1) {
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; arg1 = (OpenBabel::OBGlobalDataBase *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGlobalDataBase_Init(void * jarg1) {
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; arg1 = (OpenBabel::OBGlobalDataBase *)jarg1; 
  (arg1)->Init(); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBGlobalDataBase_GetSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; size_t result;
  arg1 = (OpenBabel::OBGlobalDataBase *)jarg1;  result = (arg1)->GetSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGlobalDataBase_SetReadDirectory(void * jarg1, char * jarg2) {
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBGlobalDataBase *)jarg1;  arg2 = (char *)jarg2;  (arg1)->SetReadDirectory(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGlobalDataBase_SetEnvironmentVariable(void * jarg1, char * jarg2) {
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBGlobalDataBase *)jarg1;  arg2 = (char *)jarg2;  (arg1)->SetEnvironmentVariable(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGlobalDataBase_ParseLine(void * jarg1, char * jarg2) {
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBGlobalDataBase *)jarg1;  arg2 = (char *)jarg2;  (arg1)->ParseLine((char const *)arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBElement__SWIG_0() { void * jresult ; OpenBabel::OBElement *result = 0 ;
  result = (OpenBabel::OBElement *)new OpenBabel::OBElement(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBElement__SWIG_1(int jarg1, char * jarg2, double jarg3, double jarg4, double jarg5, int jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, double jarg12, double jarg13, char * jarg14) {
  void * jresult ; int arg1 ; char *arg2 = (char *) 0 ; double arg3 ; double arg4 ; double arg5 ; int arg6 ; double arg7 ;
  double arg8 ; double arg9 ; double arg10 ; double arg11 ; double arg12 ; double arg13 ; std::string arg14 ;
  OpenBabel::OBElement *result = 0 ; arg1 = (int)jarg1;  arg2 = (char *)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  arg5 = (double)jarg5;  arg6 = (int)jarg6;  arg7 = (double)jarg7;  arg8 = (double)jarg8;  arg9 = (double)jarg9; 
  arg10 = (double)jarg10;  arg11 = (double)jarg11;  arg12 = (double)jarg12;  arg13 = (double)jarg13;  if (!jarg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg14)->assign(jarg14); 
  result = (OpenBabel::OBElement *)new OpenBabel::OBElement(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBElement_GetAtomicNum(void * jarg1) { int jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; int result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (int)(arg1)->GetAtomicNum(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBElement_GetSymbol(void * jarg1) { char * jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (char *)(arg1)->GetSymbol(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetCovalentRad(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetCovalentRad(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetVdwRad(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetVdwRad(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetMass(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetMass(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBElement_GetMaxBonds(void * jarg1) { int jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; int result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (int)(arg1)->GetMaxBonds(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetElectroNeg(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetElectroNeg(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetAllredRochowElectroNeg(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetAllredRochowElectroNeg(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetIonization(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetIonization(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetElectronAffinity(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetElectronAffinity(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBElement_GetName(void * jarg1) { char * jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; std::string result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (arg1)->GetName(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetRed(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetRed(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetGreen(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetGreen(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElement_GetBlue(void * jarg1) { double jresult ;
  OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ; double result; arg1 = (OpenBabel::OBElement *)jarg1; 
  result = (double)(arg1)->GetBlue(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBElement(void * jarg1) { OpenBabel::OBElement *arg1 = (OpenBabel::OBElement *) 0 ;
  arg1 = (OpenBabel::OBElement *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBElementTable() { void * jresult ; OpenBabel::OBElementTable *result = 0 ;
  result = (OpenBabel::OBElementTable *)new OpenBabel::OBElementTable(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBElementTable(void * jarg1) {
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; arg1 = (OpenBabel::OBElementTable *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBElementTable_GetNumberOfElements(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  result = (unsigned int)(arg1)->GetNumberOfElements(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBElementTable_GetAtomicNum__SWIG_0(void * jarg1, char * jarg2) { int jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; char *arg2 = (char *) 0 ; int result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (char *)jarg2;  result = (int)(arg1)->GetAtomicNum((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBElementTable_GetAtomicNum__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { int jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; char *arg2 = (char *) 0 ; int *arg3 = 0 ; int result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (char *)jarg2;  arg3 = (int *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return 0; }  
  result = (int)(arg1)->GetAtomicNum((char const *)arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBElementTable_GetSymbol(void * jarg1, int jarg2) { char * jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; char *result = 0 ;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (char *)(arg1)->GetSymbol(arg2);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetVdwRad(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetVdwRad(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetCovalentRad(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetCovalentRad(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetMass(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetMass(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_CorrectedBondRad__SWIG_0(void * jarg1, int jarg2, int jarg3) {
  double jresult ; OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(arg1)->CorrectedBondRad(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_CorrectedBondRad__SWIG_1(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->CorrectedBondRad(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_CorrectedVdwRad__SWIG_0(void * jarg1, int jarg2, int jarg3) {
  double jresult ; OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(arg1)->CorrectedVdwRad(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_CorrectedVdwRad__SWIG_1(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->CorrectedVdwRad(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBElementTable_GetMaxBonds(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (int)(arg1)->GetMaxBonds(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetElectroNeg(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetElectroNeg(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetAllredRochowElectroNeg(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetAllredRochowElectroNeg(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetIonization(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetIonization(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBElementTable_GetElectronAffinity(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (double)(arg1)->GetElectronAffinity(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElementTable_GetRGB(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->GetRGB(arg2);
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBElementTable_GetName(void * jarg1, int jarg2) { char * jresult ;
  OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ; int arg2 ; std::string result;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->GetName(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBIsotopeTable() { void * jresult ; OpenBabel::OBIsotopeTable *result = 0 ;
  result = (OpenBabel::OBIsotopeTable *)new OpenBabel::OBIsotopeTable(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBIsotopeTable(void * jarg1) {
  OpenBabel::OBIsotopeTable *arg1 = (OpenBabel::OBIsotopeTable *) 0 ; arg1 = (OpenBabel::OBIsotopeTable *)jarg1;  delete arg1; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBIsotopeTable_GetExactMass__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  double jresult ; OpenBabel::OBIsotopeTable *arg1 = (OpenBabel::OBIsotopeTable *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  double result; arg1 = (OpenBabel::OBIsotopeTable *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  result = (double)(arg1)->GetExactMass(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBIsotopeTable_GetExactMass__SWIG_1(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBIsotopeTable *arg1 = (OpenBabel::OBIsotopeTable *) 0 ; unsigned int arg2 ; double result;
  arg1 = (OpenBabel::OBIsotopeTable *)jarg1;  arg2 = (unsigned int)jarg2;  result = (double)(arg1)->GetExactMass(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTypeTable() { void * jresult ; OpenBabel::OBTypeTable *result = 0 ;
  result = (OpenBabel::OBTypeTable *)new OpenBabel::OBTypeTable(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBTypeTable(void * jarg1) {
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; arg1 = (OpenBabel::OBTypeTable *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTypeTable_SetFromType(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBTypeTable *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(arg1)->SetFromType((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTypeTable_SetToType(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBTypeTable *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(arg1)->SetToType((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTypeTable_Translate__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBTypeTable *)jarg1;  arg2 = (char *)jarg2;  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->Translate(arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTypeTable_Translate__SWIG_1(void * jarg1, char * jarg2) { char * jresult ;
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; std::string *arg2 = 0 ; std::string result;
  arg1 = (OpenBabel::OBTypeTable *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = (arg1)->Translate((std::string const &)*arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTypeTable_GetFromType(void * jarg1) { char * jresult ;
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; std::string result; arg1 = (OpenBabel::OBTypeTable *)jarg1; 
  result = (arg1)->GetFromType(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTypeTable_GetToType(void * jarg1) { char * jresult ;
  OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; std::string result; arg1 = (OpenBabel::OBTypeTable *)jarg1; 
  result = (arg1)->GetToType(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueData() { void * jresult ; OpenBabel::OBResidueData *result = 0 ;
  result = (OpenBabel::OBResidueData *)new OpenBabel::OBResidueData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueData_SetResName(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBResidueData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = (bool)(arg1)->SetResName((std::string const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBResidueData_LookupBO__SWIG_0(void * jarg1, char * jarg2) { int jresult ;
  OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; std::string *arg2 = 0 ; int result;
  arg1 = (OpenBabel::OBResidueData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = (int)(arg1)->LookupBO((std::string const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBResidueData_LookupBO__SWIG_1(void * jarg1, char * jarg2, char * jarg3) { int jresult ;
  OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; int result;
  arg1 = (OpenBabel::OBResidueData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str; 
  result = (int)(arg1)->LookupBO((std::string const &)*arg2,(std::string const &)*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueData_LookupType(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; int *arg4 = 0 ; bool result; arg1 = (OpenBabel::OBResidueData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg4 = (int *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return 0; }  
  result = (bool)(arg1)->LookupType((std::string const &)*arg2,*arg3,*arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueData_AssignBonds(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBBitVec *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBResidueData *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;
  if (!arg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0);
    return 0; }   arg3 = (OpenBabel::OBBitVec *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0);
    return 0; }   result = (bool)(arg1)->AssignBonds(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBResidueData(void * jarg1) {
  OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ; arg1 = (OpenBabel::OBResidueData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRandom__SWIG_0(unsigned int jarg1) { void * jresult ; bool arg1 ;
  OpenBabel::OBRandom *result = 0 ; arg1 = jarg1 ? true : false;  result = (OpenBabel::OBRandom *)new OpenBabel::OBRandom(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRandom__SWIG_1() { void * jresult ; OpenBabel::OBRandom *result = 0 ;
  result = (OpenBabel::OBRandom *)new OpenBabel::OBRandom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRandom_Seed(void * jarg1, int jarg2) {
  OpenBabel::OBRandom *arg1 = (OpenBabel::OBRandom *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRandom *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->Seed(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRandom_TimeSeed(void * jarg1) { OpenBabel::OBRandom *arg1 = (OpenBabel::OBRandom *) 0 ;
  arg1 = (OpenBabel::OBRandom *)jarg1;  (arg1)->TimeSeed(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRandom_NextInt(void * jarg1) { int jresult ;
  OpenBabel::OBRandom *arg1 = (OpenBabel::OBRandom *) 0 ; int result; arg1 = (OpenBabel::OBRandom *)jarg1; 
  result = (int)(arg1)->NextInt(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBRandom_NextFloat(void * jarg1) { double jresult ;
  OpenBabel::OBRandom *arg1 = (OpenBabel::OBRandom *) 0 ; double result; arg1 = (OpenBabel::OBRandom *)jarg1; 
  result = (double)(arg1)->NextFloat(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRandom(void * jarg1) { OpenBabel::OBRandom *arg1 = (OpenBabel::OBRandom *) 0 ;
  arg1 = (OpenBabel::OBRandom *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBStopwatch_Start(void * jarg1) {
  OpenBabel::OBStopwatch *arg1 = (OpenBabel::OBStopwatch *) 0 ; arg1 = (OpenBabel::OBStopwatch *)jarg1;  (arg1)->Start(); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBStopwatch_Lap(void * jarg1) { double jresult ;
  OpenBabel::OBStopwatch *arg1 = (OpenBabel::OBStopwatch *) 0 ; double result; arg1 = (OpenBabel::OBStopwatch *)jarg1; 
  result = (double)(arg1)->Lap(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBStopwatch_Elapsed(void * jarg1) { double jresult ;
  OpenBabel::OBStopwatch *arg1 = (OpenBabel::OBStopwatch *) 0 ; double result; arg1 = (OpenBabel::OBStopwatch *)jarg1; 
  result = (double)(arg1)->Elapsed(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBStopwatch() { void * jresult ; OpenBabel::OBStopwatch *result = 0 ;
  result = (OpenBabel::OBStopwatch *)new OpenBabel::OBStopwatch(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBStopwatch(void * jarg1) {
  OpenBabel::OBStopwatch *arg1 = (OpenBabel::OBStopwatch *) 0 ; arg1 = (OpenBabel::OBStopwatch *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSqrtTbl__SWIG_0() { void * jresult ; OpenBabel::OBSqrtTbl *result = 0 ;
  result = (OpenBabel::OBSqrtTbl *)new OpenBabel::OBSqrtTbl(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSqrtTbl__SWIG_1(double jarg1, double jarg2) { void * jresult ; double arg1 ;
  double arg2 ; OpenBabel::OBSqrtTbl *result = 0 ; arg1 = (double)jarg1;  arg2 = (double)jarg2; 
  result = (OpenBabel::OBSqrtTbl *)new OpenBabel::OBSqrtTbl(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSqrtTbl(void * jarg1) { OpenBabel::OBSqrtTbl *arg1 = (OpenBabel::OBSqrtTbl *) 0 ;
  arg1 = (OpenBabel::OBSqrtTbl *)jarg1;  delete arg1; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBSqrtTbl_Sqrt(void * jarg1, double jarg2) { double jresult ;
  OpenBabel::OBSqrtTbl *arg1 = (OpenBabel::OBSqrtTbl *) 0 ; double arg2 ; double result; arg1 = (OpenBabel::OBSqrtTbl *)jarg1; 
  arg2 = (double)jarg2;  result = (double)((OpenBabel::OBSqrtTbl const *)arg1)->Sqrt(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSqrtTbl_Init(void * jarg1, double jarg2, double jarg3) {
  OpenBabel::OBSqrtTbl *arg1 = (OpenBabel::OBSqrtTbl *) 0 ; double arg2 ; double arg3 ; arg1 = (OpenBabel::OBSqrtTbl *)jarg1; 
  arg2 = (double)jarg2;  arg3 = (double)jarg3;  (arg1)->Init(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_rotate_coords(void * jarg1, void * jarg2, unsigned int jarg3) { double *arg1 = (double *) 0 ;
  double (*arg2)[3] ; unsigned int arg3 ; arg1 = (double *)jarg1;  arg2 = (double (*)[3])jarg2;  arg3 = (unsigned int)jarg3; 
  OpenBabel::rotate_coords(arg1,(double (*)[3])arg2,arg3); }
SWIGEXPORT double SWIGSTDCALL CSharp_calc_rms(void * jarg1, void * jarg2, unsigned int jarg3) { double jresult ;
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; unsigned int arg3 ; double result; arg1 = (double *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (unsigned int)jarg3;  result = (double)OpenBabel::calc_rms(arg1,arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_0(double jarg1, double jarg2, double jarg3) { void * jresult ;
  double arg1 ; double arg2 ; double arg3 ; OpenBabel::vector3 *result = 0 ; arg1 = (double)jarg1;  arg2 = (double)jarg2; 
  arg3 = (double)jarg3;  result = (OpenBabel::vector3 *)new OpenBabel::vector3(arg1,arg2,arg3); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_1(double jarg1, double jarg2) { void * jresult ; double arg1 ;
  double arg2 ; OpenBabel::vector3 *result = 0 ; arg1 = (double)jarg1;  arg2 = (double)jarg2; 
  result = (OpenBabel::vector3 *)new OpenBabel::vector3(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_2(double jarg1) { void * jresult ; double arg1 ;
  OpenBabel::vector3 *result = 0 ; arg1 = (double)jarg1;  result = (OpenBabel::vector3 *)new OpenBabel::vector3(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_3() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)new OpenBabel::vector3(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_4(void * jarg1) { void * jresult ; double *arg1 ;
  OpenBabel::vector3 *result = 0 ; arg1 = (double *)jarg1;  result = (OpenBabel::vector3 *)new OpenBabel::vector3(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVector3__SWIG_5(void * jarg1) { void * jresult ; OpenBabel::vector3 *arg1 = 0 ;
  OpenBabel::vector3 *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = (OpenBabel::vector3 *)new OpenBabel::vector3((OpenBabel::vector3 const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBVector3(void * jarg1) { OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::vector3 *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_Set(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::vector3 *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (arg1)->Set(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_SetX(void * jarg1, double jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double arg2 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetX(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_SetY(void * jarg1, double jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double arg2 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetY(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_SetZ(void * jarg1, double jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double arg2 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetZ(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_GetX(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double)((OpenBabel::vector3 const *)arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_GetY(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double)((OpenBabel::vector3 const *)arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_GetZ(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double)((OpenBabel::vector3 const *)arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_Get(void * jarg1, void * jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->Get(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVector3_AsArray(void * jarg1) { void * jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double *)((OpenBabel::vector3 const *)arg1)->AsArray(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_RandomUnitVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::OBRandom *arg2 = (OpenBabel::OBRandom *) 0 ;
  arg1 = (OpenBabel::vector3 *)jarg1;  arg2 = (OpenBabel::OBRandom *)jarg2;  (arg1)->randomUnitVector(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVector3_RandomUnitVector__SWIG_1(void * jarg1) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  (arg1)->randomUnitVector(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVector3_Normalize(void * jarg1) { void * jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::vector3 *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (OpenBabel::vector3 *) &(arg1)->normalize(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBVector3_CanBeNormalized(void * jarg1) { unsigned int jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; bool result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (bool)((OpenBabel::vector3 const *)arg1)->CanBeNormalized(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_LengthSq(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double)((OpenBabel::vector3 const *)arg1)->length_2(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_Length(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double)((OpenBabel::vector3 const *)arg1)->length(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_x__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double *) &((OpenBabel::vector3 const *)arg1)->x(); jresult = *result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_y__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double *) &((OpenBabel::vector3 const *)arg1)->y(); jresult = *result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_z__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  result = (double *) &((OpenBabel::vector3 const *)arg1)->z(); jresult = *result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBVector3_IsApprox(void * jarg1, void * jarg2, double jarg3) { unsigned int jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ; double *arg3 = 0 ; double temp3 ;
  bool result; arg1 = (OpenBabel::vector3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   temp3 = (double)jarg3;  arg3 = &temp3; 
  result = (bool)((OpenBabel::vector3 const *)arg1)->IsApprox((OpenBabel::vector3 const &)*arg2,(double const &)*arg3);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBVector3_DistSq(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ; double result;
  arg1 = (OpenBabel::vector3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = (double)((OpenBabel::vector3 const *)arg1)->distSq((OpenBabel::vector3 const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBVector3_CreateOrthoVector(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::vector3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (bool)((OpenBabel::vector3 const *)arg1)->createOrthoVector(*arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_dot(void * jarg1, void * jarg2) { double jresult ; OpenBabel::vector3 *arg1 = 0 ;
  OpenBabel::vector3 *arg2 = 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = (double)OpenBabel::dot((OpenBabel::vector3 const &)*arg1,(OpenBabel::vector3 const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_cross(void * jarg1, void * jarg2) { void * jresult ; OpenBabel::vector3 *arg1 = 0 ;
  OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = OpenBabel::cross((OpenBabel::vector3 const &)*arg1,(OpenBabel::vector3 const &)*arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_vectorAngle(void * jarg1, void * jarg2) { double jresult ; OpenBabel::vector3 *arg1 = 0 ;
  OpenBabel::vector3 *arg2 = 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = (double)OpenBabel::vectorAngle((OpenBabel::vector3 const &)*arg1,(OpenBabel::vector3 const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_CalcTorsionAngle(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { double jresult ;
  OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 *arg4 = 0 ;
  double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }  
  result = (double)OpenBabel::CalcTorsionAngle((OpenBabel::vector3 const &)*arg1,(OpenBabel::vector3 const &)*arg2,(OpenBabel::vector3 const &)*arg3,(OpenBabel::vector3 const &)*arg4);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_Point2PlaneSigned(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; OpenBabel::vector3 arg1 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ; OpenBabel::vector3 arg4 ;
  OpenBabel::vector3 *argp1 ; OpenBabel::vector3 *argp2 ; OpenBabel::vector3 *argp3 ; OpenBabel::vector3 *argp4 ; double result;
  argp1 = (OpenBabel::vector3 *)jarg1;  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg1 = *argp1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg3 = *argp3;  argp4 = (OpenBabel::vector3 *)jarg4;  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg4 = *argp4;  result = (double)OpenBabel::Point2PlaneSigned(arg1,arg2,arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_Point2Plane(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { double jresult ;
  OpenBabel::vector3 arg1 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ; OpenBabel::vector3 arg4 ;
  OpenBabel::vector3 *argp1 ; OpenBabel::vector3 *argp2 ; OpenBabel::vector3 *argp3 ; OpenBabel::vector3 *argp4 ; double result;
  argp1 = (OpenBabel::vector3 *)jarg1;  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg1 = *argp1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg3 = *argp3;  argp4 = (OpenBabel::vector3 *)jarg4;  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg4 = *argp4;  result = (double)OpenBabel::Point2Plane(arg1,arg2,arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_Point2PlaneAngle(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { double jresult ;
  OpenBabel::vector3 arg1 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ; OpenBabel::vector3 arg4 ;
  OpenBabel::vector3 const *argp1 ; OpenBabel::vector3 const *argp2 ; OpenBabel::vector3 const *argp3 ;
  OpenBabel::vector3 const *argp4 ; double result; argp1 = (OpenBabel::vector3 *)jarg1;  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return 0; }  arg1 = *argp1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return 0; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return 0; }  arg3 = *argp3;  argp4 = (OpenBabel::vector3 *)jarg4;  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return 0; }  arg4 = *argp4;  result = (double)OpenBabel::Point2PlaneAngle(arg1,arg2,arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_Point2Line(void * jarg1, void * jarg2, void * jarg3) { double jresult ;
  OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ; double result;
  arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }  
  result = (double)OpenBabel::Point2Line((OpenBabel::vector3 const &)*arg1,(OpenBabel::vector3 const &)*arg2,(OpenBabel::vector3 const &)*arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VZero_get() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)&OpenBabel::VZero; jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VX_get() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)&OpenBabel::VX; jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VY_get() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)&OpenBabel::VY; jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VZ_get() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)&OpenBabel::VZ; jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMatrix3x3__SWIG_0() { void * jresult ; OpenBabel::matrix3x3 *result = 0 ;
  result = (OpenBabel::matrix3x3 *)new OpenBabel::matrix3x3(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMatrix3x3__SWIG_1(double jarg1) { void * jresult ; double arg1 ;
  OpenBabel::matrix3x3 *result = 0 ; arg1 = (double)jarg1;  result = (OpenBabel::matrix3x3 *)new OpenBabel::matrix3x3(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMatrix3x3__SWIG_2(void * jarg1, void * jarg2, void * jarg3) { void * jresult ;
  OpenBabel::vector3 arg1 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ; OpenBabel::vector3 *argp1 ;
  OpenBabel::vector3 *argp2 ; OpenBabel::vector3 *argp3 ; OpenBabel::matrix3x3 *result = 0 ;
  argp1 = (OpenBabel::vector3 *)jarg1;  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg1 = *argp1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg3 = *argp3;  result = (OpenBabel::matrix3x3 *)new OpenBabel::matrix3x3(arg1,arg2,arg3);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMatrix3x3(void * jarg1) { OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_GetArray(void * jarg1, void * jarg2) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->GetArray(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrix3x3_inverse(void * jarg1) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::matrix3x3 result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = ((OpenBabel::matrix3x3 const *)arg1)->inverse();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrix3x3_transpose(void * jarg1) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::matrix3x3 result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = ((OpenBabel::matrix3x3 const *)arg1)->transpose();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_randomRotation(void * jarg1, void * jarg2) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::OBRandom *arg2 = 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (OpenBabel::OBRandom *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRandom & type is null", 0); return ; }
    (arg1)->randomRotation(*arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMatrix3x3_determinant(void * jarg1) { double jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; double result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = (double)((OpenBabel::matrix3x3 const *)arg1)->determinant(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMatrix3x3_isSymmetric(void * jarg1) { unsigned int jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; bool result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = (bool)((OpenBabel::matrix3x3 const *)arg1)->isSymmetric(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMatrix3x3_isOrthogonal(void * jarg1) { unsigned int jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; bool result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = (bool)((OpenBabel::matrix3x3 const *)arg1)->isOrthogonal(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMatrix3x3_isDiagonal(void * jarg1) { unsigned int jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; bool result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = (bool)((OpenBabel::matrix3x3 const *)arg1)->isDiagonal(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMatrix3x3_isUnitMatrix(void * jarg1) { unsigned int jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; bool result; arg1 = (OpenBabel::matrix3x3 *)jarg1; 
  result = (bool)((OpenBabel::matrix3x3 const *)arg1)->isUnitMatrix(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMatrix3x3_Get(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)((OpenBabel::matrix3x3 const *)arg1)->Get(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_Set(void * jarg1, int jarg2, int jarg3, double jarg4) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; int arg2 ; int arg3 ; double arg4 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (double)jarg4; 
  (arg1)->Set(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_SetColumn(void * jarg1, int jarg2, void * jarg3) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; int arg2 ; OpenBabel::vector3 *arg3 = 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->SetColumn(arg2,(OpenBabel::vector3 const &)*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_SetRow(void * jarg1, int jarg2, void * jarg3) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; int arg2 ; OpenBabel::vector3 *arg3 = 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->SetRow(arg2,(OpenBabel::vector3 const &)*arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrix3x3_GetColumn(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; unsigned int arg2 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = ((OpenBabel::matrix3x3 const *)arg1)->GetColumn(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrix3x3_GetRow(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; unsigned int arg2 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = ((OpenBabel::matrix3x3 const *)arg1)->GetRow(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_SetupRotMat(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (arg1)->SetupRotMat(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_PlaneReflection(void * jarg1, void * jarg2) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->PlaneReflection((OpenBabel::vector3 const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_RotAboutAxisByAngle(void * jarg1, void * jarg2, double jarg3) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ; double arg3 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   arg3 = (double)jarg3;  (arg1)->RotAboutAxisByAngle((OpenBabel::vector3 const &)*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_FillOrth(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; double arg2 ; double arg3 ; double arg4 ; double arg5 ;
  double arg6 ; double arg7 ; arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3; 
  arg4 = (double)jarg4;  arg5 = (double)jarg5;  arg6 = (double)jarg6;  arg7 = (double)jarg7; 
  (arg1)->FillOrth(arg2,arg3,arg4,arg5,arg6,arg7); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrix3x3_findEigenvectorsIfSymmetric(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = ((OpenBabel::matrix3x3 const *)arg1)->findEigenvectorsIfSymmetric(*arg2);
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrix3x3_jacobi(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int arg1 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; double *arg4 = (double *) 0 ;
  arg1 = (unsigned int)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  arg4 = (double *)jarg4; 
  OpenBabel::matrix3x3::jacobi(arg1,arg2,arg3,arg4); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTransform3d__SWIG_0() { void * jresult ; OpenBabel::transform3d *result = 0 ;
  result = (OpenBabel::transform3d *)new OpenBabel::transform3d(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTransform3d__SWIG_1(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::matrix3x3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::transform3d *result = 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::matrix3x3 const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }  
  result = (OpenBabel::transform3d *)new OpenBabel::transform3d((OpenBabel::matrix3x3 const &)*arg1,(OpenBabel::vector3 const &)*arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTransform3d__SWIG_2(double jarg1) { void * jresult ; double arg1 ;
  OpenBabel::transform3d *result = 0 ; arg1 = (double)jarg1; 
  result = (OpenBabel::transform3d *)new OpenBabel::transform3d(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTransform3d__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ; OpenBabel::vector3 arg1 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ; OpenBabel::vector3 arg4 ;
  OpenBabel::vector3 *argp1 ; OpenBabel::vector3 *argp2 ; OpenBabel::vector3 *argp3 ; OpenBabel::vector3 *argp4 ;
  OpenBabel::transform3d *result = 0 ; argp1 = (OpenBabel::vector3 *)jarg1;  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg1 = *argp1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg3 = *argp3;  argp4 = (OpenBabel::vector3 *)jarg4;  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg4 = *argp4;  result = (OpenBabel::transform3d *)new OpenBabel::transform3d(arg1,arg2,arg3,arg4);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTransform3d_DescribeAsString(void * jarg1) { char * jresult ;
  OpenBabel::transform3d *arg1 = (OpenBabel::transform3d *) 0 ; std::string result; arg1 = (OpenBabel::transform3d *)jarg1; 
  result = ((OpenBabel::transform3d const *)arg1)->DescribeAsString();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTransform3d_DescribeAsValues(void * jarg1) { char * jresult ;
  OpenBabel::transform3d *arg1 = (OpenBabel::transform3d *) 0 ; std::string result; arg1 = (OpenBabel::transform3d *)jarg1; 
  result = ((OpenBabel::transform3d const *)arg1)->DescribeAsValues();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBTransform3d_Normalize(void * jarg1) {
  OpenBabel::transform3d *arg1 = (OpenBabel::transform3d *) 0 ; arg1 = (OpenBabel::transform3d *)jarg1;  (arg1)->Normalize(); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBTransform3d(void * jarg1) {
  OpenBabel::transform3d *arg1 = (OpenBabel::transform3d *) 0 ; arg1 = (OpenBabel::transform3d *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_SpaceGroup() { void * jresult ; OpenBabel::SpaceGroup *result = 0 ;
  result = (OpenBabel::SpaceGroup *)new OpenBabel::SpaceGroup(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_SpaceGroup(void * jarg1) { OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ;
  arg1 = (OpenBabel::SpaceGroup *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_SpaceGroup_SetHMName__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetHMName((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_SpaceGroup_SetHallName__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetHallName((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_SpaceGroup_SetId(void * jarg1, unsigned int jarg2) {
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetId(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_SpaceGroup_AddTransform(void * jarg1, char * jarg2) {
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->AddTransform((std::string const &)*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_SpaceGroup_GetHMName(void * jarg1) { char * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; std::string *result = 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  result = (std::string *) &((OpenBabel::SpaceGroup const *)arg1)->GetHMName();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_SpaceGroup_GetHallName(void * jarg1) { char * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; std::string *result = 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  result = (std::string *) &((OpenBabel::SpaceGroup const *)arg1)->GetHallName();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SpaceGroup_GetId(void * jarg1) { unsigned int jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; unsigned int result; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  result = (unsigned int)((OpenBabel::SpaceGroup const *)arg1)->GetId(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_SpaceGroup_GetSpaceGroup__SWIG_0(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::SpaceGroup *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::SpaceGroup *)OpenBabel::SpaceGroup::GetSpaceGroup((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_SpaceGroup_GetSpaceGroup__SWIG_2(unsigned int jarg1) { void * jresult ; unsigned int arg1 ;
  OpenBabel::SpaceGroup *result = 0 ; arg1 = (unsigned int)jarg1; 
  result = (OpenBabel::SpaceGroup *)OpenBabel::SpaceGroup::GetSpaceGroup(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_SpaceGroup_Find(void * jarg1) { void * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; OpenBabel::SpaceGroup *result = 0 ;
  arg1 = (OpenBabel::SpaceGroup *)jarg1;  result = (OpenBabel::SpaceGroup *)OpenBabel::SpaceGroup::Find(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SpaceGroup_IsValid(void * jarg1) { unsigned int jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; bool result; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  result = (bool)((OpenBabel::SpaceGroup const *)arg1)->IsValid(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBReleaseVersion() { char * jresult ; std::string result;
  result = OpenBabel::OBReleaseVersion(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGenericData__SWIG_0(char * jarg1, unsigned int jarg2, int jarg3) { void * jresult ;
  std::string arg1 ; unsigned int arg2 ; OpenBabel::DataOrigin arg3 ; OpenBabel::OBGenericData *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg1)->assign(jarg1);  arg2 = (unsigned int)jarg2;  arg3 = (OpenBabel::DataOrigin)jarg3; 
  result = (OpenBabel::OBGenericData *)new OpenBabel::OBGenericData(arg1,arg2,arg3); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGenericData__SWIG_1(char * jarg1, unsigned int jarg2) { void * jresult ;
  std::string arg1 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg1)->assign(jarg1);  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)new OpenBabel::OBGenericData(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGenericData__SWIG_2(char * jarg1) { void * jresult ; std::string arg1 ;
  OpenBabel::OBGenericData *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg1)->assign(jarg1);  result = (OpenBabel::OBGenericData *)new OpenBabel::OBGenericData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGenericData__SWIG_3() { void * jresult ; OpenBabel::OBGenericData *result = 0 ;
  result = (OpenBabel::OBGenericData *)new OpenBabel::OBGenericData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBGenericData(void * jarg1) {
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBGenericData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGenericData_SetAttribute(void * jarg1, char * jarg2) {
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetAttribute((std::string const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGenericData_SetOrigin(void * jarg1, int jarg2) {
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::DataOrigin arg2 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  arg2 = (OpenBabel::DataOrigin)jarg2;  (arg1)->SetOrigin(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBGenericData_GetAttribute(void * jarg1) { char * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (std::string *) &((OpenBabel::OBGenericData const *)arg1)->GetAttribute();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBGenericData_GetDataType(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (unsigned int)((OpenBabel::OBGenericData const *)arg1)->GetDataType();
  jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBGenericData_GetValue(void * jarg1) { char * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (std::string *) &((OpenBabel::OBGenericData const *)arg1)->GetValue();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBGenericData_GetOrigin(void * jarg1) { int jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::DataOrigin result;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::DataOrigin)((OpenBabel::OBGenericData const *)arg1)->GetOrigin(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToAngleData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBAngleData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBAngleData *)OpenBabel_OBGenericData_ToAngleData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToAtomClassData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBAtomClassData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::OBAtomClassData *)OpenBabel_OBGenericData_ToAtomClassData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToChiralData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBChiralData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBChiralData *)OpenBabel_OBGenericData_ToChiralData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToCommentData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBCommentData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBCommentData *)OpenBabel_OBGenericData_ToCommentData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToConformerData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBConformerData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::OBConformerData *)OpenBabel_OBGenericData_ToConformerData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToExternalBondData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBExternalBondData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::OBExternalBondData *)OpenBabel_OBGenericData_ToExternalBondData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToGridData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBGridData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBGridData *)OpenBabel_OBGenericData_ToGridData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToMatrixData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBMatrixData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBMatrixData *)OpenBabel_OBGenericData_ToMatrixData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToNasaThermoData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBNasaThermoData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::OBNasaThermoData *)OpenBabel_OBGenericData_ToNasaThermoData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToPairData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBPairData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBPairData *)OpenBabel_OBGenericData_ToPairData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToRateData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBRateData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBRateData *)OpenBabel_OBGenericData_ToRateData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToRotamerList(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBRotamerList *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBRotamerList *)OpenBabel_OBGenericData_ToRotamerList(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToRotationData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBRotationData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBRotationData *)OpenBabel_OBGenericData_ToRotationData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToSetData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBSetData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBSetData *)OpenBabel_OBGenericData_ToSetData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToSymmetryData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBSymmetryData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBSymmetryData *)OpenBabel_OBGenericData_ToSymmetryData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToTorsionData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBTorsionData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBTorsionData *)OpenBabel_OBGenericData_ToTorsionData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToUnitCell(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBUnitCell *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBUnitCell *)OpenBabel_OBGenericData_ToUnitCell(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToVectorData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBVectorData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBVectorData *)OpenBabel_OBGenericData_ToVectorData(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToVibrationData(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBVibrationData *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1; 
  result = (OpenBabel::OBVibrationData *)OpenBabel_OBGenericData_ToVibrationData(arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGenericData_ToVirtualBond(void * jarg1) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBVirtualBond *result = 0 ;
  arg1 = (OpenBabel::OBGenericData *)jarg1;  result = (OpenBabel::OBVirtualBond *)OpenBabel_OBGenericData_ToVirtualBond(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBBase(void * jarg1) { OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBase_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; bool result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = (bool)(arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_DoTransformations(void * jarg1, void * jarg2, void * jarg3) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ;
  OpenBabel::OBConversion *arg3 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  arg3 = (OpenBabel::OBConversion *)jarg3; 
  result = (OpenBabel::OBBase *)(arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2,arg3);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBBase_ClassDescription() { char * jresult ; char *result = 0 ;
  result = (char *)OpenBabel::OBBase::ClassDescription(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBBase_GetTitle__SWIG_0(void * jarg1, unsigned int jarg2) { char * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; bool arg2 ; char *result = 0 ; arg1 = (OpenBabel::OBBase *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (char *)((OpenBabel::OBBase const *)arg1)->GetTitle(arg2);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBBase_GetTitle__SWIG_1(void * jarg1) { char * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = (char *)((OpenBabel::OBBase const *)arg1)->GetTitle(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBase_SetTitle(void * jarg1, char * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::OBBase *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetTitle((char const *)arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBase_HasData__SWIG_0(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; bool result; arg1 = (OpenBabel::OBBase *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = (bool)(arg1)->HasData((std::string const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBase_HasData__SWIG_2(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; unsigned int arg2 ; bool result; arg1 = (OpenBabel::OBBase *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (bool)(arg1)->HasData(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBase_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBBase *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBase_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (OpenBabel::OBGenericData *)jarg2;  (arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBase_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (std::vector< OpenBabel::OBGenericData * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > & type is null", 0);
    return ; }   (arg1)->DeleteData(*arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBase_DeleteData__SWIG_3(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; bool result; arg1 = (OpenBabel::OBBase *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = (bool)(arg1)->DeleteData((std::string const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBase_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (OpenBabel::OBGenericData *)jarg2;  (arg1)->CloneData(arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBBase_DataSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; size_t result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = ((OpenBabel::OBBase const *)arg1)->DataSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (unsigned int)jarg2;  result = (OpenBabel::OBGenericData *)(arg1)->GetData(arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_GetData__SWIG_1(void * jarg1, char * jarg2) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (OpenBabel::OBGenericData *)(arg1)->GetData((std::string const &)*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; unsigned int arg2 ; std::vector< OpenBabel::OBGenericData * > result;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (unsigned int)jarg2;  result = (arg1)->GetAllData(arg2);
  jresult = new std::vector< OpenBabel::OBGenericData * >((const std::vector< OpenBabel::OBGenericData * > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  result = (std::vector< OpenBabel::OBGenericData * > *) &(arg1)->GetData();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (OpenBabel::DataOrigin)jarg2; 
  result = (arg1)->GetData(arg2);
  jresult = new std::vector< OpenBabel::OBGenericData * >((const std::vector< OpenBabel::OBGenericData * > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBase() { void * jresult ; OpenBabel::OBBase *result = 0 ;
  result = (OpenBabel::OBBase *)new OpenBabel::OBBase(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBCommentData__SWIG_0() { void * jresult ; OpenBabel::OBCommentData *result = 0 ;
  result = (OpenBabel::OBCommentData *)new OpenBabel::OBCommentData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBCommentData__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBCommentData *arg1 = 0 ; OpenBabel::OBCommentData *result = 0 ; arg1 = (OpenBabel::OBCommentData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBCommentData const & type is null", 0);
    return 0; }   result = (OpenBabel::OBCommentData *)new OpenBabel::OBCommentData((OpenBabel::OBCommentData const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBCommentData_SetData__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBCommentData *arg1 = (OpenBabel::OBCommentData *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBCommentData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetData((std::string const &)*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBCommentData_GetData(void * jarg1) { char * jresult ;
  OpenBabel::OBCommentData *arg1 = (OpenBabel::OBCommentData *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBCommentData *)jarg1;  result = (std::string *) &((OpenBabel::OBCommentData const *)arg1)->GetData();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBCommentData(void * jarg1) {
  OpenBabel::OBCommentData *arg1 = (OpenBabel::OBCommentData *) 0 ; arg1 = (OpenBabel::OBCommentData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBExternalBond__SWIG_0() { void * jresult ; OpenBabel::OBExternalBond *result = 0 ;
  result = (OpenBabel::OBExternalBond *)new OpenBabel::OBExternalBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBExternalBond__SWIG_1(void * jarg1, void * jarg2, int jarg3) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; int arg3 ;
  OpenBabel::OBExternalBond *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  arg3 = (int)jarg3;  result = (OpenBabel::OBExternalBond *)new OpenBabel::OBExternalBond(arg1,arg2,arg3);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBExternalBond__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBExternalBond *arg1 = 0 ; OpenBabel::OBExternalBond *result = 0 ; arg1 = (OpenBabel::OBExternalBond *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBExternalBond const & type is null", 0);
    return 0; }   result = (OpenBabel::OBExternalBond *)new OpenBabel::OBExternalBond((OpenBabel::OBExternalBond const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBExternalBond(void * jarg1) {
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; arg1 = (OpenBabel::OBExternalBond *)jarg1;  delete arg1; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBExternalBond_GetIdx(void * jarg1) { int jresult ;
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; int result; arg1 = (OpenBabel::OBExternalBond *)jarg1; 
  result = (int)((OpenBabel::OBExternalBond const *)arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBExternalBond_GetAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBExternalBond *)jarg1; 
  result = (OpenBabel::OBAtom *)((OpenBabel::OBExternalBond const *)arg1)->GetAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBExternalBond_GetBond(void * jarg1) { void * jresult ;
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBExternalBond *)jarg1; 
  result = (OpenBabel::OBBond *)((OpenBabel::OBExternalBond const *)arg1)->GetBond(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBExternalBond_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; int arg2 ; arg1 = (OpenBabel::OBExternalBond *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBExternalBond_SetAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBExternalBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->SetAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBExternalBond_SetBond(void * jarg1, void * jarg2) {
  OpenBabel::OBExternalBond *arg1 = (OpenBabel::OBExternalBond *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBExternalBond *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (arg1)->SetBond(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBExternalBondData() { void * jresult ; OpenBabel::OBExternalBondData *result = 0 ;
  result = (OpenBabel::OBExternalBondData *)new OpenBabel::OBExternalBondData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBExternalBondData_SetData(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBExternalBondData *arg1 = (OpenBabel::OBExternalBondData *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; int arg4 ;
  arg1 = (OpenBabel::OBExternalBondData *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBBond *)jarg3; 
  arg4 = (int)jarg4;  (arg1)->SetData(arg2,arg3,arg4); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBExternalBondData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBExternalBondData *arg1 = (OpenBabel::OBExternalBondData *) 0 ;
  std::vector< OpenBabel::OBExternalBond > *result = 0 ; arg1 = (OpenBabel::OBExternalBondData *)jarg1; 
  result = (std::vector< OpenBabel::OBExternalBond > *)(arg1)->GetData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBExternalBondData(void * jarg1) {
  OpenBabel::OBExternalBondData *arg1 = (OpenBabel::OBExternalBondData *) 0 ; arg1 = (OpenBabel::OBExternalBondData *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBPairData() { void * jresult ; OpenBabel::OBPairData *result = 0 ;
  result = (OpenBabel::OBPairData *)new OpenBabel::OBPairData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBPairData_SetValue__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBPairData *arg1 = (OpenBabel::OBPairData *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::OBPairData *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetValue((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBPairData(void * jarg1) { OpenBabel::OBPairData *arg1 = (OpenBabel::OBPairData *) 0 ;
  arg1 = (OpenBabel::OBPairData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSetData() { void * jresult ; OpenBabel::OBSetData *result = 0 ;
  result = (OpenBabel::OBSetData *)new OpenBabel::OBSetData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSetData_AddData(void * jarg1, void * jarg2) {
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ; OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1;  arg2 = (OpenBabel::OBGenericData *)jarg2;  (arg1)->AddData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSetData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1;  arg2 = (std::vector< OpenBabel::OBGenericData * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBGenericData * > & type is null", 0);
    return ; }   (arg1)->SetData(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSetData_GetData__SWIG_0(void * jarg1, char * jarg2) { void * jresult ;
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ; char *arg2 = (char *) 0 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1;  arg2 = (char *)jarg2; 
  result = (OpenBabel::OBGenericData *)(arg1)->GetData((char const *)arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSetData_GetData__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1; 
  result = (std::vector< OpenBabel::OBGenericData * > *) &((OpenBabel::OBSetData const *)arg1)->GetData();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSetData_DeleteData(void * jarg1, void * jarg2) {
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ; OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1;  arg2 = (OpenBabel::OBGenericData *)jarg2;  (arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSetData(void * jarg1) { OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ;
  arg1 = (OpenBabel::OBSetData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVirtualBond__SWIG_0() { void * jresult ; OpenBabel::OBVirtualBond *result = 0 ;
  result = (OpenBabel::OBVirtualBond *)new OpenBabel::OBVirtualBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVirtualBond__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) { void * jresult ;
  int arg1 ; int arg2 ; int arg3 ; int arg4 ; OpenBabel::OBVirtualBond *result = 0 ; arg1 = (int)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  result = (OpenBabel::OBVirtualBond *)new OpenBabel::OBVirtualBond(arg1,arg2,arg3,arg4); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVirtualBond__SWIG_2(int jarg1, int jarg2, int jarg3) { void * jresult ; int arg1 ;
  int arg2 ; int arg3 ; OpenBabel::OBVirtualBond *result = 0 ; arg1 = (int)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (OpenBabel::OBVirtualBond *)new OpenBabel::OBVirtualBond(arg1,arg2,arg3); jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBVirtualBond_GetBgn(void * jarg1) { int jresult ;
  OpenBabel::OBVirtualBond *arg1 = (OpenBabel::OBVirtualBond *) 0 ; int result; arg1 = (OpenBabel::OBVirtualBond *)jarg1; 
  result = (int)(arg1)->GetBgn(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBVirtualBond_GetEnd(void * jarg1) { int jresult ;
  OpenBabel::OBVirtualBond *arg1 = (OpenBabel::OBVirtualBond *) 0 ; int result; arg1 = (OpenBabel::OBVirtualBond *)jarg1; 
  result = (int)(arg1)->GetEnd(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBVirtualBond_GetOrder(void * jarg1) { int jresult ;
  OpenBabel::OBVirtualBond *arg1 = (OpenBabel::OBVirtualBond *) 0 ; int result; arg1 = (OpenBabel::OBVirtualBond *)jarg1; 
  result = (int)(arg1)->GetOrder(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBVirtualBond_GetStereo(void * jarg1) { int jresult ;
  OpenBabel::OBVirtualBond *arg1 = (OpenBabel::OBVirtualBond *) 0 ; int result; arg1 = (OpenBabel::OBVirtualBond *)jarg1; 
  result = (int)(arg1)->GetStereo(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBVirtualBond(void * jarg1) {
  OpenBabel::OBVirtualBond *arg1 = (OpenBabel::OBVirtualBond *) 0 ; arg1 = (OpenBabel::OBVirtualBond *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRingData__SWIG_0() { void * jresult ; OpenBabel::OBRingData *result = 0 ;
  result = (OpenBabel::OBRingData *)new OpenBabel::OBRingData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRingData__SWIG_1(void * jarg1) { void * jresult ; OpenBabel::OBRingData *arg1 = 0 ;
  OpenBabel::OBRingData *result = 0 ; arg1 = (OpenBabel::OBRingData *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRingData const & type is null", 0);
    return 0; }   result = (OpenBabel::OBRingData *)new OpenBabel::OBRingData((OpenBabel::OBRingData const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRingData(void * jarg1) { OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ;
  arg1 = (OpenBabel::OBRingData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ; std::vector< OpenBabel::OBRing * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBRingData *)jarg1;  arg2 = (std::vector< OpenBabel::OBRing * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * > & type is null", 0);
    return ; }   (arg1)->SetData(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingData_PushBack(void * jarg1, void * jarg2) {
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ; OpenBabel::OBRing *arg2 = (OpenBabel::OBRing *) 0 ;
  arg1 = (OpenBabel::OBRingData *)jarg1;  arg2 = (OpenBabel::OBRing *)jarg2;  (arg1)->PushBack(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  arg1 = (OpenBabel::OBRingData *)jarg1;  result = (std::vector< OpenBabel::OBRing * > *) &(arg1)->GetData();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBUnitCell__SWIG_0() { void * jresult ; OpenBabel::OBUnitCell *result = 0 ;
  result = (OpenBabel::OBUnitCell *)new OpenBabel::OBUnitCell(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBUnitCell__SWIG_1(void * jarg1) { void * jresult ; OpenBabel::OBUnitCell *arg1 = 0 ;
  OpenBabel::OBUnitCell *result = 0 ; arg1 = (OpenBabel::OBUnitCell *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBUnitCell const & type is null", 0);
    return 0; }   result = (OpenBabel::OBUnitCell *)new OpenBabel::OBUnitCell((OpenBabel::OBUnitCell const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBUnitCell(void * jarg1) { OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetData__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double arg2 ; double arg3 ; double arg4 ; double arg5 ;
  double arg6 ; double arg7 ; arg1 = (OpenBabel::OBUnitCell *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3; 
  arg4 = (double)jarg4;  arg5 = (double)jarg5;  arg6 = (double)jarg6;  arg7 = (double)jarg7; 
  (arg1)->SetData(arg2,arg3,arg4,arg5,arg6,arg7); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetData__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 arg3 ;
  OpenBabel::vector3 arg4 ; OpenBabel::vector3 const *argp2 ; OpenBabel::vector3 const *argp3 ;
  OpenBabel::vector3 const *argp4 ; arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return ; }  arg2 = *argp2;  argp3 = (OpenBabel::vector3 *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return ; }  arg3 = *argp3;  argp4 = (OpenBabel::vector3 *)jarg4;  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return ; }  arg4 = *argp4;  (arg1)->SetData(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::matrix3x3 arg2 ; OpenBabel::matrix3x3 const *argp2 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::matrix3x3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::matrix3x3 const", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetOffset(void * jarg1, void * jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 const *argp2 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3 const", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetOffset(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetSpaceGroup__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::SpaceGroup *arg2 = (OpenBabel::SpaceGroup *) 0 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  arg2 = (OpenBabel::SpaceGroup *)jarg2; 
  (arg1)->SetSpaceGroup((OpenBabel::SpaceGroup const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetSpaceGroup__SWIG_1(void * jarg1, char * jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; std::string arg2 ; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetSpaceGroup(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetSpaceGroup__SWIG_2(void * jarg1, int jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; int arg2 ; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetSpaceGroup(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_SetLatticeType(void * jarg1, int jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::OBUnitCell::LatticeType arg2 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  arg2 = (OpenBabel::OBUnitCell::LatticeType)jarg2;  (arg1)->SetLatticeType(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBUnitCell_FillUnitCell(void * jarg1, void * jarg2) {
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (arg1)->FillUnitCell(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetA(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetA(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetB(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetB(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetC(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetC(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetAlpha(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetAlpha(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetBeta(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetBeta(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetGamma(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetGamma(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetOffset(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (arg1)->GetOffset(); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetSpaceGroup(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::SpaceGroup *result = 0 ;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (OpenBabel::SpaceGroup *)(arg1)->GetSpaceGroup(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBUnitCell_GetSpaceGroupName(void * jarg1) { char * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; std::string result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (arg1)->GetSpaceGroupName(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBUnitCell_GetLatticeType__SWIG_0(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; int arg2 ; OpenBabel::OBUnitCell::LatticeType result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBUnitCell::LatticeType)(arg1)->GetLatticeType(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBUnitCell_GetLatticeType__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::OBUnitCell::LatticeType result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (OpenBabel::OBUnitCell::LatticeType)(arg1)->GetLatticeType();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetCellVectors(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; std::vector< OpenBabel::vector3 > result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (arg1)->GetCellVectors();
  jresult = new std::vector< OpenBabel::vector3 >((const std::vector< OpenBabel::vector3 > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetCellMatrix(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (arg1)->GetCellMatrix();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetOrthoMatrix(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (arg1)->GetOrthoMatrix();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetOrientationMatrix(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (arg1)->GetOrientationMatrix();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_GetFractionalMatrix(void * jarg1) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  result = (arg1)->GetFractionalMatrix();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_FractionalToCartesian(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  OpenBabel::vector3 result; arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  result = (arg1)->FractionalToCartesian(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_CartesianToFractional(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  OpenBabel::vector3 result; arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  result = (arg1)->CartesianToFractional(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_WrapCartesianCoordinate(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  OpenBabel::vector3 result; arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  result = (arg1)->WrapCartesianCoordinate(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBUnitCell_WrapFractionalCoordinate(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  OpenBabel::vector3 result; arg1 = (OpenBabel::OBUnitCell *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  result = (arg1)->WrapFractionalCoordinate(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBUnitCell_GetSpaceGroupNumber__SWIG_0(void * jarg1, char * jarg2) { int jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; std::string arg2 ; int result;
  arg1 = (OpenBabel::OBUnitCell *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg2)->assign(jarg2);  result = (int)(arg1)->GetSpaceGroupNumber(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBUnitCell_GetSpaceGroupNumber__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; int result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (int)(arg1)->GetSpaceGroupNumber(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBUnitCell_GetCellVolume(void * jarg1) { double jresult ;
  OpenBabel::OBUnitCell *arg1 = (OpenBabel::OBUnitCell *) 0 ; double result; arg1 = (OpenBabel::OBUnitCell *)jarg1; 
  result = (double)(arg1)->GetCellVolume(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConformerData__SWIG_0() { void * jresult ; OpenBabel::OBConformerData *result = 0 ;
  result = (OpenBabel::OBConformerData *)new OpenBabel::OBConformerData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConformerData__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = 0 ; OpenBabel::OBConformerData *result = 0 ; arg1 = (OpenBabel::OBConformerData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBConformerData const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBConformerData *)new OpenBabel::OBConformerData((OpenBabel::OBConformerData const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBConformerData(void * jarg1) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; arg1 = (OpenBabel::OBConformerData *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetDimension(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< unsigned short > arg2 ;
  std::vector< unsigned short > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1; 
  argp2 = (std::vector< unsigned short > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< unsigned short >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetDimension(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetEnergies(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< double > arg2 ;
  std::vector< double > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1;  argp2 = (std::vector< double > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetEnergies(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetForces(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > arg2 ;
  std::vector< std::vector< OpenBabel::vector3 > > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1; 
  argp2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< OpenBabel::vector3 > >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetForces(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetVelocities(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > arg2 ;
  std::vector< std::vector< OpenBabel::vector3 > > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1; 
  argp2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< OpenBabel::vector3 > >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetVelocities(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetDisplacements(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > arg2 ;
  std::vector< std::vector< OpenBabel::vector3 > > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1; 
  argp2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< OpenBabel::vector3 > >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetDisplacements(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConformerData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::string > arg2 ;
  std::vector< std::string > *argp2 ; arg1 = (OpenBabel::OBConformerData *)jarg1;  argp2 = (std::vector< std::string > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::string >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetData(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetDimension(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< unsigned short > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetDimension();
  jresult = new std::vector< unsigned short >((const std::vector< unsigned short > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetEnergies(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetEnergies();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetForces(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetForces();
  jresult = new std::vector< std::vector< OpenBabel::vector3 > >((const std::vector< std::vector< OpenBabel::vector3 > > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetVelocities(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetVelocities();
  jresult = new std::vector< std::vector< OpenBabel::vector3 > >((const std::vector< std::vector< OpenBabel::vector3 > > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetDisplacements(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetDisplacements();
  jresult = new std::vector< std::vector< OpenBabel::vector3 > >((const std::vector< std::vector< OpenBabel::vector3 > > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConformerData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBConformerData *arg1 = (OpenBabel::OBConformerData *) 0 ; std::vector< std::string > result;
  arg1 = (OpenBabel::OBConformerData *)jarg1;  result = (arg1)->GetData();
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSymmetryData__SWIG_0() { void * jresult ; OpenBabel::OBSymmetryData *result = 0 ;
  result = (OpenBabel::OBSymmetryData *)new OpenBabel::OBSymmetryData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSymmetryData__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBSymmetryData *arg1 = 0 ; OpenBabel::OBSymmetryData *result = 0 ; arg1 = (OpenBabel::OBSymmetryData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBSymmetryData const & type is null", 0);
    return 0; }   result = (OpenBabel::OBSymmetryData *)new OpenBabel::OBSymmetryData((OpenBabel::OBSymmetryData const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSymmetryData(void * jarg1) {
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; arg1 = (OpenBabel::OBSymmetryData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSymmetryData_SetData__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string arg2 ; std::string arg3 ;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg3)->assign(jarg3);  (arg1)->SetData(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSymmetryData_SetData__SWIG_1(void * jarg1, char * jarg2) {
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string arg2 ;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSymmetryData_SetPointGroup(void * jarg1, char * jarg2) {
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string arg2 ;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetPointGroup(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSymmetryData_SetSpaceGroup(void * jarg1, char * jarg2) {
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string arg2 ;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetSpaceGroup(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBSymmetryData_GetPointGroup(void * jarg1) { char * jresult ;
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string result;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  result = (arg1)->GetPointGroup();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBSymmetryData_GetSpaceGroup(void * jarg1) { char * jresult ;
  OpenBabel::OBSymmetryData *arg1 = (OpenBabel::OBSymmetryData *) 0 ; std::string result;
  arg1 = (OpenBabel::OBSymmetryData *)jarg1;  result = (arg1)->GetSpaceGroup();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBTorsion__SWIG_2(void * jarg1) { void * jresult ; OpenBabel::OBTorsion *arg1 = 0 ;
  OpenBabel::OBTorsion *result = 0 ; arg1 = (OpenBabel::OBTorsion *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion const & type is null", 0);
    return 0; }   result = (OpenBabel::OBTorsion *)new OpenBabel::OBTorsion((OpenBabel::OBTorsion const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBTorsion(void * jarg1) { OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBTorsion_Clear(void * jarg1) { OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_Empty(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; bool result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = (bool)(arg1)->Empty(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_AddTorsion(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  unsigned int jresult ; OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg5 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (OpenBabel::OBAtom *)jarg4;  arg5 = (OpenBabel::OBAtom *)jarg5; 
  result = (bool)(arg1)->AddTorsion(arg2,arg3,arg4,arg5); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_SetAngle__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; double arg2 ; unsigned int arg3 ;
  bool result; arg1 = (OpenBabel::OBTorsion *)jarg1;  arg2 = (double)jarg2;  arg3 = (unsigned int)jarg3; 
  result = (bool)(arg1)->SetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_SetAngle__SWIG_1(void * jarg1, double jarg2) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; double arg2 ; bool result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  arg2 = (double)jarg2;  result = (bool)(arg1)->SetAngle(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_SetData(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; bool result;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  result = (bool)(arg1)->SetData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_GetAngle__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; double *arg2 = 0 ; unsigned int arg3 ;
  bool result; arg1 = (OpenBabel::OBTorsion *)jarg1;  arg2 = (double *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "double & type is null", 0); return 0; }  
  arg3 = (unsigned int)jarg3;  result = (bool)(arg1)->GetAngle(*arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_GetAngle__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; double *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  arg2 = (double *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "double & type is null", 0); return 0; }  
  result = (bool)(arg1)->GetAngle(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_GetBondIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; unsigned int result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = (unsigned int)(arg1)->GetBondIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBTorsion_GetSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; size_t result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = ((OpenBabel::OBTorsion const *)arg1)->GetSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBTorsion_GetADs(void * jarg1) { void * jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,double > > > result;
  arg1 = (OpenBabel::OBTorsion *)jarg1;  result = (arg1)->GetADs();
  jresult = new std::vector< OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,double > >((const std::vector< OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,double > > &)result); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsion_IsProtonRotor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; bool result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = (bool)(arg1)->IsProtonRotor(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBTorsionData_Clear(void * jarg1) {
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; arg1 = (OpenBabel::OBTorsionData *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBTorsionData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; std::vector< OpenBabel::OBTorsion > result;
  arg1 = (OpenBabel::OBTorsionData *)jarg1;  result = ((OpenBabel::OBTorsionData const *)arg1)->GetData();
  jresult = new std::vector< OpenBabel::OBTorsion >((const std::vector< OpenBabel::OBTorsion > &)result);  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBTorsionData_GetSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; size_t result; arg1 = (OpenBabel::OBTorsionData *)jarg1; 
  result = ((OpenBabel::OBTorsionData const *)arg1)->GetSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBTorsionData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; OpenBabel::OBTorsion *arg2 = 0 ;
  arg1 = (OpenBabel::OBTorsionData *)jarg1;  arg2 = (OpenBabel::OBTorsion *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTorsion & type is null", 0);
    return ; }   (arg1)->SetData(*arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBTorsionData_FillTorsionArray(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; std::vector< std::vector< unsigned int > > *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBTorsionData *)jarg1;  arg2 = (std::vector< std::vector< unsigned int > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > & type is null", 0);
    return 0; }   result = (bool)(arg1)->FillTorsionArray(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBTorsionData(void * jarg1) {
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; arg1 = (OpenBabel::OBTorsionData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAngle__SWIG_2(void * jarg1) { void * jresult ; OpenBabel::OBAngle *arg1 = 0 ;
  OpenBabel::OBAngle *result = 0 ; arg1 = (OpenBabel::OBAngle *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAngle const & type is null", 0);
    return 0; }   result = (OpenBabel::OBAngle *)new OpenBabel::OBAngle((OpenBabel::OBAngle const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAngle(void * jarg1) { OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ;
  arg1 = (OpenBabel::OBAngle *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAngle_Clear(void * jarg1) { OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ;
  arg1 = (OpenBabel::OBAngle *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAngle_GetAngle(void * jarg1) { double jresult ;
  OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ; double result; arg1 = (OpenBabel::OBAngle *)jarg1; 
  result = (double)((OpenBabel::OBAngle const *)arg1)->GetAngle(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAngle_SetAngle(void * jarg1, double jarg2) {
  OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ; double arg2 ; arg1 = (OpenBabel::OBAngle *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetAngle(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAngle_SetAtoms(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAngle *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (OpenBabel::OBAtom *)jarg4;  (arg1)->SetAtoms(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAngleData_Clear(void * jarg1) {
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; arg1 = (OpenBabel::OBAngleData *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAngleData_FillAngleArray(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; std::vector< std::vector< unsigned int > > *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBAngleData *)jarg1;  arg2 = (std::vector< std::vector< unsigned int > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< unsigned int > > & type is null", 0);
    return 0; }   result = (bool)(arg1)->FillAngleArray(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAngleData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; OpenBabel::OBAngle *arg2 = 0 ;
  arg1 = (OpenBabel::OBAngleData *)jarg1;  arg2 = (OpenBabel::OBAngle *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAngle & type is null", 0); return ; }
    (arg1)->SetData(*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBAngleData_GetSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; size_t result; arg1 = (OpenBabel::OBAngleData *)jarg1; 
  result = ((OpenBabel::OBAngleData const *)arg1)->GetSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAngleData(void * jarg1) {
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; arg1 = (OpenBabel::OBAngleData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBChiralData__SWIG_0() { void * jresult ; OpenBabel::OBChiralData *result = 0 ;
  result = (OpenBabel::OBChiralData *)new OpenBabel::OBChiralData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBChiralData__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBChiralData *arg1 = 0 ; OpenBabel::OBChiralData *result = 0 ; arg1 = (OpenBabel::OBChiralData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBChiralData const & type is null", 0);
    return 0; }   result = (OpenBabel::OBChiralData *)new OpenBabel::OBChiralData((OpenBabel::OBChiralData const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBChiralData(void * jarg1) {
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; arg1 = (OpenBabel::OBChiralData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBChiralData_Clear(void * jarg1) {
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; arg1 = (OpenBabel::OBChiralData *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBChiralData_GetAtom4Refs(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; OpenBabel::atomreftype arg2 ;
  std::vector< unsigned int > result; arg1 = (OpenBabel::OBChiralData *)jarg1;  arg2 = (OpenBabel::atomreftype)jarg2; 
  result = ((OpenBabel::OBChiralData const *)arg1)->GetAtom4Refs(arg2);
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBChiralData_GetAtomRef(void * jarg1, int jarg2, int jarg3) { unsigned int jresult ;
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; int arg2 ; OpenBabel::atomreftype arg3 ; unsigned int result;
  arg1 = (OpenBabel::OBChiralData *)jarg1;  arg2 = (int)jarg2;  arg3 = (OpenBabel::atomreftype)jarg3; 
  result = (unsigned int)(arg1)->GetAtomRef(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBChiralData_SetAtom4Refs(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ; OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; std::vector< unsigned int > arg2 ;
  OpenBabel::atomreftype arg3 ; std::vector< unsigned int > *argp2 ; bool result; arg1 = (OpenBabel::OBChiralData *)jarg1; 
  argp2 = (std::vector< unsigned int > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< unsigned int >", 0);
    return 0; }  arg2 = *argp2;  arg3 = (OpenBabel::atomreftype)jarg3;  result = (bool)(arg1)->SetAtom4Refs(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBChiralData_AddAtomRef(void * jarg1, unsigned int jarg2, int jarg3) { int jresult ;
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; unsigned int arg2 ; OpenBabel::atomreftype arg3 ; int result;
  arg1 = (OpenBabel::OBChiralData *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (OpenBabel::atomreftype)jarg3; 
  result = (int)(arg1)->AddAtomRef(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBChiralData_GetSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBChiralData *arg1 = (OpenBabel::OBChiralData *) 0 ; OpenBabel::atomreftype arg2 ; unsigned int result;
  arg1 = (OpenBabel::OBChiralData *)jarg1;  arg2 = (OpenBabel::atomreftype)jarg2; 
  result = (unsigned int)((OpenBabel::OBChiralData const *)arg1)->GetSize(arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSerialNums__SWIG_0() { void * jresult ; OpenBabel::OBSerialNums *result = 0 ;
  result = (OpenBabel::OBSerialNums *)new OpenBabel::OBSerialNums(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSerialNums__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBSerialNums *arg1 = 0 ; OpenBabel::OBSerialNums *result = 0 ; arg1 = (OpenBabel::OBSerialNums *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBSerialNums const & type is null", 0);
    return 0; }   result = (OpenBabel::OBSerialNums *)new OpenBabel::OBSerialNums((OpenBabel::OBSerialNums const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSerialNums_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBSerialNums *arg1 = (OpenBabel::OBSerialNums *) 0 ; std::map< int,OpenBabel::OBAtom * > *result = 0 ;
  arg1 = (OpenBabel::OBSerialNums *)jarg1;  result = (std::map< int,OpenBabel::OBAtom * > *) &(arg1)->GetData();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSerialNums_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBSerialNums *arg1 = (OpenBabel::OBSerialNums *) 0 ; std::map< int,OpenBabel::OBAtom * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBSerialNums *)jarg1;  arg2 = (std::map< int,OpenBabel::OBAtom * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< int,OpenBabel::OBAtom * > & type is null", 0);
    return ; }   (arg1)->SetData(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSerialNums(void * jarg1) {
  OpenBabel::OBSerialNums *arg1 = (OpenBabel::OBSerialNums *) 0 ; arg1 = (OpenBabel::OBSerialNums *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVibrationData() { void * jresult ; OpenBabel::OBVibrationData *result = 0 ;
  result = (OpenBabel::OBVibrationData *)new OpenBabel::OBVibrationData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBVibrationData(void * jarg1) {
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; arg1 = (OpenBabel::OBVibrationData *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVibrationData_SetData__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg2 = 0 ; std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ; arg1 = (OpenBabel::OBVibrationData *)jarg1; 
  arg2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return ; }   arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg4 = (std::vector< double > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }  
  (arg1)->SetData((std::vector< std::vector< OpenBabel::vector3 > > const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVibrationData_SetData__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ;
  std::vector< std::vector< OpenBabel::vector3 > > *arg2 = 0 ; std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ; std::vector< double > *arg5 = 0 ; arg1 = (OpenBabel::OBVibrationData *)jarg1; 
  arg2 = (std::vector< std::vector< OpenBabel::vector3 > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< OpenBabel::vector3 > > const & type is null", 0);
    return ; }   arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg4 = (std::vector< double > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg5 = (std::vector< double > *)jarg5; if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }  
  (arg1)->SetData((std::vector< std::vector< OpenBabel::vector3 > > const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< double > const &)*arg5); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVibrationData_GetLx(void * jarg1) { void * jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; std::vector< std::vector< OpenBabel::vector3 > > result;
  arg1 = (OpenBabel::OBVibrationData *)jarg1;  result = ((OpenBabel::OBVibrationData const *)arg1)->GetLx();
  jresult = new std::vector< std::vector< OpenBabel::vector3 > >((const std::vector< std::vector< OpenBabel::vector3 > > &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVibrationData_GetFrequencies(void * jarg1) { void * jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBVibrationData *)jarg1;  result = ((OpenBabel::OBVibrationData const *)arg1)->GetFrequencies();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVibrationData_GetIntensities(void * jarg1) { void * jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBVibrationData *)jarg1;  result = ((OpenBabel::OBVibrationData const *)arg1)->GetIntensities();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVibrationData_GetRamanActivities(void * jarg1) { void * jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBVibrationData *)jarg1;  result = ((OpenBabel::OBVibrationData const *)arg1)->GetRamanActivities();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBVibrationData_GetNumberOfFrequencies(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBVibrationData *)jarg1; 
  result = (unsigned int)((OpenBabel::OBVibrationData const *)arg1)->GetNumberOfFrequencies(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBDOSData() { void * jresult ; OpenBabel::OBDOSData *result = 0 ;
  result = (OpenBabel::OBDOSData *)new OpenBabel::OBDOSData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBDOSData(void * jarg1) { OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ;
  arg1 = (OpenBabel::OBDOSData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBDOSData_SetData(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ; double arg2 ; std::vector< double > *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ; std::vector< double > *arg5 = 0 ; arg1 = (OpenBabel::OBDOSData *)jarg1; 
  arg2 = (double)jarg2;  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg4 = (std::vector< double > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg5 = (std::vector< double > *)jarg5; if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }  
  (arg1)->SetData(arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,(std::vector< double > const &)*arg5); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDOSData_GetFermiEnergy(void * jarg1) { double jresult ;
  OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ; double result; arg1 = (OpenBabel::OBDOSData *)jarg1; 
  result = (double)((OpenBabel::OBDOSData const *)arg1)->GetFermiEnergy(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDOSData_GetEnergies(void * jarg1) { void * jresult ;
  OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ; std::vector< double > result; arg1 = (OpenBabel::OBDOSData *)jarg1; 
  result = ((OpenBabel::OBDOSData const *)arg1)->GetEnergies();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDOSData_GetDensities(void * jarg1) { void * jresult ;
  OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ; std::vector< double > result; arg1 = (OpenBabel::OBDOSData *)jarg1; 
  result = ((OpenBabel::OBDOSData const *)arg1)->GetDensities();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDOSData_GetIntegration(void * jarg1) { void * jresult ;
  OpenBabel::OBDOSData *arg1 = (OpenBabel::OBDOSData *) 0 ; std::vector< double > result; arg1 = (OpenBabel::OBDOSData *)jarg1; 
  result = ((OpenBabel::OBDOSData const *)arg1)->GetIntegration();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbital_SetData__SWIG_0(void * jarg1, double jarg2, double jarg3, char * jarg4) {
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; double arg2 ; double arg3 ; std::string arg4 ;
  arg1 = (OpenBabel::OBOrbital *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg4)->assign(jarg4);  (arg1)->SetData(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbital_SetData__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; double arg2 ; double arg3 ; arg1 = (OpenBabel::OBOrbital *)jarg1; 
  arg2 = (double)jarg2;  arg3 = (double)jarg3;  (arg1)->SetData(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbital_SetData__SWIG_2(void * jarg1, double jarg2) {
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; double arg2 ; arg1 = (OpenBabel::OBOrbital *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetData(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBOrbital_GetEnergy(void * jarg1) { double jresult ;
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; double result; arg1 = (OpenBabel::OBOrbital *)jarg1; 
  result = (double)((OpenBabel::OBOrbital const *)arg1)->GetEnergy(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBOrbital_GetOccupation(void * jarg1) { double jresult ;
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; double result; arg1 = (OpenBabel::OBOrbital *)jarg1; 
  result = (double)((OpenBabel::OBOrbital const *)arg1)->GetOccupation(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBOrbital_GetSymbol(void * jarg1) { char * jresult ;
  OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ; std::string result; arg1 = (OpenBabel::OBOrbital *)jarg1; 
  result = ((OpenBabel::OBOrbital const *)arg1)->GetSymbol(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBOrbital() { void * jresult ; OpenBabel::OBOrbital *result = 0 ;
  result = (OpenBabel::OBOrbital *)new OpenBabel::OBOrbital(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBOrbital(void * jarg1) { OpenBabel::OBOrbital *arg1 = (OpenBabel::OBOrbital *) 0 ;
  arg1 = (OpenBabel::OBOrbital *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBOrbitalData() { void * jresult ; OpenBabel::OBOrbitalData *result = 0 ;
  result = (OpenBabel::OBOrbitalData *)new OpenBabel::OBOrbitalData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBOrbitalData(void * jarg1) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; arg1 = (OpenBabel::OBOrbitalData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_SetAlphaOrbitals(void * jarg1, void * jarg2) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBOrbital > > arg2 ; std::vector< OpenBabel::OBOrbital > *argp2 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  argp2 = (std::vector< OpenBabel::OBOrbital > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< OpenBabel::OBOrbital >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetAlphaOrbitals(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_SetBetaOrbitals(void * jarg1, void * jarg2) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBOrbital > > arg2 ; std::vector< OpenBabel::OBOrbital > *argp2 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  argp2 = (std::vector< OpenBabel::OBOrbital > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< OpenBabel::OBOrbital >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetBetaOrbitals(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_SetHOMO__SWIG_0(void * jarg1, int jarg2, int jarg3) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; int arg2 ; int arg3 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  (arg1)->SetHOMO(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_SetHOMO__SWIG_1(void * jarg1, int jarg2) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; int arg2 ; arg1 = (OpenBabel::OBOrbitalData *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetHOMO(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_SetOpenShell(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBOrbitalData *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetOpenShell(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOrbitalData_IsOpenShell(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; bool result; arg1 = (OpenBabel::OBOrbitalData *)jarg1; 
  result = (bool)(arg1)->IsOpenShell(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOrbitalData_GetAlphaHOMO(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  result = (unsigned int)(arg1)->GetAlphaHOMO(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOrbitalData_GetBetaHOMO(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  result = (unsigned int)(arg1)->GetBetaHOMO(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBOrbitalData_GetAlphaOrbitals(void * jarg1) { void * jresult ;
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBOrbital > > result; arg1 = (OpenBabel::OBOrbitalData *)jarg1; 
  result = (arg1)->GetAlphaOrbitals();
  jresult = new std::vector< OpenBabel::OBOrbital >((const std::vector< OpenBabel::OBOrbital > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBOrbitalData_GetBetaOrbitals(void * jarg1) { void * jresult ;
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBOrbital > > result; arg1 = (OpenBabel::OBOrbitalData *)jarg1; 
  result = (arg1)->GetBetaOrbitals();
  jresult = new std::vector< OpenBabel::OBOrbital >((const std::vector< OpenBabel::OBOrbital > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_LoadClosedShellOrbitals(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; std::vector< double > arg2 ;
  std::vector< std::string > arg3 ; int arg4 ; std::vector< double > *argp2 ; std::vector< std::string > *argp3 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  argp2 = (std::vector< double > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return ; }  arg2 = *argp2;  argp3 = (std::vector< std::string > *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::string >", 0);
    return ; }  arg3 = *argp3;  arg4 = (int)jarg4;  (arg1)->LoadClosedShellOrbitals(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_LoadAlphaOrbitals(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; std::vector< double > arg2 ;
  std::vector< std::string > arg3 ; int arg4 ; std::vector< double > *argp2 ; std::vector< std::string > *argp3 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  argp2 = (std::vector< double > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return ; }  arg2 = *argp2;  argp3 = (std::vector< std::string > *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::string >", 0);
    return ; }  arg3 = *argp3;  arg4 = (int)jarg4;  (arg1)->LoadAlphaOrbitals(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBOrbitalData_LoadBetaOrbitals(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBOrbitalData *arg1 = (OpenBabel::OBOrbitalData *) 0 ; std::vector< double > arg2 ;
  std::vector< std::string > arg3 ; int arg4 ; std::vector< double > *argp2 ; std::vector< std::string > *argp3 ;
  arg1 = (OpenBabel::OBOrbitalData *)jarg1;  argp2 = (std::vector< double > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return ; }  arg2 = *argp2;  argp3 = (std::vector< std::string > *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::string >", 0);
    return ; }  arg3 = *argp3;  arg4 = (int)jarg4;  (arg1)->LoadBetaOrbitals(arg2,arg3,arg4); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBElectronicTransitionData() { void * jresult ;
  OpenBabel::OBElectronicTransitionData *result = 0 ;
  result = (OpenBabel::OBElectronicTransitionData *)new OpenBabel::OBElectronicTransitionData(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBElectronicTransitionData(void * jarg1) {
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBElectronicTransitionData_SetData(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ; arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->SetData((std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBElectronicTransitionData_SetEDipole(void * jarg1, void * jarg2) {
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->SetEDipole((std::vector< double > const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBElectronicTransitionData_SetRotatoryStrengthsVelocity(void * jarg1, void * jarg2) {
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->SetRotatoryStrengthsVelocity((std::vector< double > const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBElectronicTransitionData_SetRotatoryStrengthsLength(void * jarg1, void * jarg2) {
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->SetRotatoryStrengthsLength((std::vector< double > const &)*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElectronicTransitionData_GetWavelengths(void * jarg1) { void * jresult ;
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  result = ((OpenBabel::OBElectronicTransitionData const *)arg1)->GetWavelengths();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElectronicTransitionData_GetForces(void * jarg1) { void * jresult ;
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  result = ((OpenBabel::OBElectronicTransitionData const *)arg1)->GetForces();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElectronicTransitionData_GetEDipole(void * jarg1) { void * jresult ;
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  result = ((OpenBabel::OBElectronicTransitionData const *)arg1)->GetEDipole();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElectronicTransitionData_GetRotatoryStrengthsVelocity(void * jarg1) { void * jresult ;
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  result = ((OpenBabel::OBElectronicTransitionData const *)arg1)->GetRotatoryStrengthsVelocity();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBElectronicTransitionData_GetRotatoryStrengthsLength(void * jarg1) { void * jresult ;
  OpenBabel::OBElectronicTransitionData *arg1 = (OpenBabel::OBElectronicTransitionData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBElectronicTransitionData *)jarg1; 
  result = ((OpenBabel::OBElectronicTransitionData const *)arg1)->GetRotatoryStrengthsLength();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotationData() { void * jresult ; OpenBabel::OBRotationData *result = 0 ;
  result = (OpenBabel::OBRotationData *)new OpenBabel::OBRotationData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotationData(void * jarg1) {
  OpenBabel::OBRotationData *arg1 = (OpenBabel::OBRotationData *) 0 ; arg1 = (OpenBabel::OBRotationData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotationData_SetData(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBRotationData *arg1 = (OpenBabel::OBRotationData *) 0 ; OpenBabel::OBRotationData::RType arg2 ;
  std::vector< double > arg3 ; int arg4 ; std::vector< double > *argp3 ; arg1 = (OpenBabel::OBRotationData *)jarg1; 
  arg2 = (OpenBabel::OBRotationData::RType)jarg2;  argp3 = (std::vector< double > *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return ; }  arg3 = *argp3;  arg4 = (int)jarg4;  (arg1)->SetData(arg2,arg3,arg4); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotationData_GetRotConsts(void * jarg1) { void * jresult ;
  OpenBabel::OBRotationData *arg1 = (OpenBabel::OBRotationData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBRotationData *)jarg1;  result = ((OpenBabel::OBRotationData const *)arg1)->GetRotConsts();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRotationData_GetSymmetryNumber(void * jarg1) { int jresult ;
  OpenBabel::OBRotationData *arg1 = (OpenBabel::OBRotationData *) 0 ; int result; arg1 = (OpenBabel::OBRotationData *)jarg1; 
  result = (int)((OpenBabel::OBRotationData const *)arg1)->GetSymmetryNumber(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRotationData_GetRotorType(void * jarg1) { int jresult ;
  OpenBabel::OBRotationData *arg1 = (OpenBabel::OBRotationData *) 0 ; OpenBabel::OBRotationData::RType result;
  arg1 = (OpenBabel::OBRotationData *)jarg1; 
  result = (OpenBabel::OBRotationData::RType)((OpenBabel::OBRotationData const *)arg1)->GetRotorType(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBVectorData() { void * jresult ; OpenBabel::OBVectorData *result = 0 ;
  result = (OpenBabel::OBVectorData *)new OpenBabel::OBVectorData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBVectorData(void * jarg1) {
  OpenBabel::OBVectorData *arg1 = (OpenBabel::OBVectorData *) 0 ; arg1 = (OpenBabel::OBVectorData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVectorData_SetData__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBVectorData *arg1 = (OpenBabel::OBVectorData *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBVectorData *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (arg1)->SetData(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBVectorData_SetData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBVectorData *arg1 = (OpenBabel::OBVectorData *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  arg1 = (OpenBabel::OBVectorData *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetData(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBVectorData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBVectorData *arg1 = (OpenBabel::OBVectorData *) 0 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBVectorData *)jarg1;  result = ((OpenBabel::OBVectorData const *)arg1)->GetData();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMatrixData() { void * jresult ; OpenBabel::OBMatrixData *result = 0 ;
  result = (OpenBabel::OBMatrixData *)new OpenBabel::OBMatrixData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMatrixData(void * jarg1) {
  OpenBabel::OBMatrixData *arg1 = (OpenBabel::OBMatrixData *) 0 ; arg1 = (OpenBabel::OBMatrixData *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMatrixData_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBMatrixData *arg1 = (OpenBabel::OBMatrixData *) 0 ; OpenBabel::matrix3x3 arg2 ; OpenBabel::matrix3x3 *argp2 ;
  arg1 = (OpenBabel::OBMatrixData *)jarg1;  argp2 = (OpenBabel::matrix3x3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::matrix3x3", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetData(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMatrixData_GetData(void * jarg1) { void * jresult ;
  OpenBabel::OBMatrixData *arg1 = (OpenBabel::OBMatrixData *) 0 ; OpenBabel::matrix3x3 result;
  arg1 = (OpenBabel::OBMatrixData *)jarg1;  result = ((OpenBabel::OBMatrixData const *)arg1)->GetData();
  jresult = new OpenBabel::matrix3x3((const OpenBabel::matrix3x3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBGridData() { void * jresult ; OpenBabel::OBGridData *result = 0 ;
  result = (OpenBabel::OBGridData *)new OpenBabel::OBGridData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBGridData(void * jarg1) { OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetXAxis(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = ((OpenBabel::OBGridData const *)arg1)->GetXAxis();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetYAxis(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = ((OpenBabel::OBGridData const *)arg1)->GetYAxis();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetZAxis(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = ((OpenBabel::OBGridData const *)arg1)->GetZAxis();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_GetAxes(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ;
  OpenBabel::vector3 *arg4 = 0 ; arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return ; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return ; }
    arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return ; }
    ((OpenBabel::OBGridData const *)arg1)->GetAxes(*arg2,*arg3,*arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_GetNumberOfPoints__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int *arg2 = 0 ; int *arg3 = 0 ; int *arg4 = 0 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (int *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  arg3 = (int *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  arg4 = (int *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  ((OpenBabel::OBGridData const *)arg1)->GetNumberOfPoints(*arg2,*arg3,*arg4); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBGridData_GetNumberOfPoints__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (int)((OpenBabel::OBGridData const *)arg1)->GetNumberOfPoints(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_GetNumberOfSteps(void * jarg1, void * jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int *arg2 ; arg1 = (OpenBabel::OBGridData *)jarg1; 
  arg2 = (int *)jarg2;  ((OpenBabel::OBGridData const *)arg1)->GetNumberOfSteps(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetValues(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; std::vector< double > result;
  arg1 = (OpenBabel::OBGridData *)jarg1;  result = ((OpenBabel::OBGridData const *)arg1)->GetValues();
  jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBGridData_GetValue__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4) {
  double jresult ; OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int arg2 ; int arg3 ; int arg4 ; double result;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  result = (double)((OpenBabel::OBGridData const *)arg1)->GetValue(arg2,arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBGridData_GetValue__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 arg2 ; OpenBabel::vector3 *argp2 ;
  double result; arg1 = (OpenBabel::OBGridData *)jarg1;  argp2 = (OpenBabel::vector3 *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::vector3", 0);
    return 0; }  arg2 = *argp2;  result = (double)((OpenBabel::OBGridData const *)arg1)->GetValue(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBGridData_GetUnit(void * jarg1) { int jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::OBGridData::Unit result;
  arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (OpenBabel::OBGridData::Unit)((OpenBabel::OBGridData const *)arg1)->GetUnit(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBGridData_GetMinValue(void * jarg1) { double jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; double result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (double)((OpenBabel::OBGridData const *)arg1)->GetMinValue(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBGridData_GetMaxValue(void * jarg1) { double jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; double result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (double)((OpenBabel::OBGridData const *)arg1)->GetMaxValue(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetOriginVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = ((OpenBabel::OBGridData const *)arg1)->GetOriginVector();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_GetOriginVector__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; double *arg2 ; arg1 = (OpenBabel::OBGridData *)jarg1; 
  arg2 = (double *)jarg2;  ((OpenBabel::OBGridData const *)arg1)->GetOriginVector(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBGridData_GetMaxVector(void * jarg1) { void * jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = ((OpenBabel::OBGridData const *)arg1)->GetMaxVector();
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBGridData_GetUnrestricted(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; bool result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (bool)((OpenBabel::OBGridData const *)arg1)->GetUnrestricted(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBGridData_GetNumSymmetries(void * jarg1) { int jresult ;
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int result; arg1 = (OpenBabel::OBGridData *)jarg1; 
  result = (int)((OpenBabel::OBGridData const *)arg1)->GetNumSymmetries(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetNumberOfPoints(void * jarg1, int jarg2, int jarg3, int jarg4) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int arg2 ; int arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  (arg1)->SetNumberOfPoints(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetLimits__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ;
  OpenBabel::vector3 *arg4 = 0 ; OpenBabel::vector3 *arg5 = 0 ; arg1 = (OpenBabel::OBGridData *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   arg5 = (OpenBabel::vector3 *)jarg5; if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }  
  (arg1)->SetLimits((OpenBabel::vector3 const &)*arg2,(OpenBabel::vector3 const &)*arg3,(OpenBabel::vector3 const &)*arg4,(OpenBabel::vector3 const &)*arg5); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetLimits__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; double *arg2 ; double *arg3 ; double *arg4 ; double *arg5 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  arg4 = (double *)jarg4; 
  arg5 = (double *)jarg5; 
  (arg1)->SetLimits((double const (*))arg2,(double const (*))arg3,(double const (*))arg4,(double const (*))arg5); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBGridData_SetValue(void * jarg1, int jarg2, int jarg3, int jarg4, double jarg5) {
  unsigned int jresult ; OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int arg2 ; int arg3 ; int arg4 ;
  double arg5 ; bool result; arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  arg5 = (double)jarg5;  result = (bool)(arg1)->SetValue(arg2,arg3,arg4,arg5); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetValues(void * jarg1, void * jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; std::vector< double > *arg2 = 0 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   (arg1)->SetValues((std::vector< double > const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetUnit(void * jarg1, int jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; OpenBabel::OBGridData::Unit arg2 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (OpenBabel::OBGridData::Unit)jarg2;  (arg1)->SetUnit(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetUnrestricted(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBGridData *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetUnrestricted(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBGridData_SetNumSymmetries(void * jarg1, int jarg2) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; int arg2 ; arg1 = (OpenBabel::OBGridData *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetNumSymmetries(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBChainsParser() { void * jresult ; OpenBabel::OBChainsParser *result = 0 ;
  result = (OpenBabel::OBChainsParser *)new OpenBabel::OBChainsParser(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBChainsParser(void * jarg1) {
  OpenBabel::OBChainsParser *arg1 = (OpenBabel::OBChainsParser *) 0 ; arg1 = (OpenBabel::OBChainsParser *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBChainsParser_PerceiveChains__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBChainsParser *arg1 = (OpenBabel::OBChainsParser *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  bool arg3 ; bool result; arg1 = (OpenBabel::OBChainsParser *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = jarg3 ? true : false;  result = (bool)(arg1)->PerceiveChains(*arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBChainsParser_PerceiveChains__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ; OpenBabel::OBChainsParser *arg1 = (OpenBabel::OBChainsParser *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBChainsParser *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->PerceiveChains(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomTyper() { void * jresult ; OpenBabel::OBAtomTyper *result = 0 ;
  result = (OpenBabel::OBAtomTyper *)new OpenBabel::OBAtomTyper(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAtomTyper(void * jarg1) {
  OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ; arg1 = (OpenBabel::OBAtomTyper *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomTyper_AssignHyb(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->AssignHyb(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomTyper_AssignTypes(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->AssignTypes(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomTyper_AssignImplicitValence(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->AssignImplicitValence(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomTyper_CorrectAromaticNitrogens(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->CorrectAromaticNitrogens(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRingTyper() { void * jresult ; OpenBabel::OBRingTyper *result = 0 ;
  result = (OpenBabel::OBRingTyper *)new OpenBabel::OBRingTyper(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRingTyper(void * jarg1) {
  OpenBabel::OBRingTyper *arg1 = (OpenBabel::OBRingTyper *) 0 ; arg1 = (OpenBabel::OBRingTyper *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingTyper_AssignTypes(void * jarg1, void * jarg2) {
  OpenBabel::OBRingTyper *arg1 = (OpenBabel::OBRingTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBRingTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->AssignTypes(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_dummy() { void * jresult ;
  std::binary_function< char const *,char const *,bool > *result = 0 ;
  result = (std::binary_function< char const *,char const *,bool > *)new std::binary_function< char const *,char const *,bool >();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_dummy(void * jarg1) {
  std::binary_function< char const *,char const *,bool > *arg1 = (std::binary_function< char const *,char const *,bool > *) 0 ;
  arg1 = (std::binary_function< char const *,char const *,bool > *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBPlugin(void * jarg1) { OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ;
  arg1 = (OpenBabel::OBPlugin *)jarg1;  delete arg1; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_Description(void * jarg1) { char * jresult ;
  OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBPlugin *)jarg1; 
  result = (char *)(arg1)->Description(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBPlugin *)jarg1; 
  result = (char *)(arg1)->TypeID(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBPlugin_Display__SWIG_0(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
  unsigned int jresult ; OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; char *arg4 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBPlugin *)jarg1; 
  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  arg4 = (char *)jarg4;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3,(char const *)arg4);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBPlugin_Display__SWIG_1(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBPlugin *)jarg1;  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBPlugin_MakeInstance(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; std::vector< std::string > *arg2 = 0 ;
  OpenBabel::OBPlugin *result = 0 ; arg1 = (OpenBabel::OBPlugin *)jarg1;  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0; }   result = (OpenBabel::OBPlugin *)(arg1)->MakeInstance((std::vector< std::string > const &)*arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBPlugin_Init(void * jarg1) { OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ;
  arg1 = (OpenBabel::OBPlugin *)jarg1;  (arg1)->Init(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBPlugin_GetPlugin(char * jarg1, char * jarg2) { void * jresult ; char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ; OpenBabel::OBPlugin *result = 0 ; arg1 = (char *)jarg1;  arg2 = (char *)jarg2; 
  result = (OpenBabel::OBPlugin *)OpenBabel::OBPlugin::GetPlugin((char const *)arg1,(char const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_GetID(void * jarg1) { char * jresult ;
  OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBPlugin *)jarg1; 
  result = (char *)((OpenBabel::OBPlugin const *)arg1)->GetID(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBPlugin_ListAsVector(char * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ; char *arg1 = (char *) 0 ; char *arg2 = (char *) 0 ; std::vector< std::string > *arg3 = 0 ; bool result;
  arg1 = (char *)jarg1;  arg2 = (char *)jarg2;  arg3 = (std::vector< std::string > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > & type is null", 0);
    return 0; }   result = (bool)OpenBabel::OBPlugin::ListAsVector((char const *)arg1,(char const *)arg2,*arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBPlugin_List__SWIG_0(char * jarg1, char * jarg2, void * jarg3) { char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ; std::ostream *arg3 = (std::ostream *) 0 ; arg1 = (char *)jarg1;  arg2 = (char *)jarg2; 
  arg3 = (std::ostream *)jarg3;  OpenBabel::OBPlugin::List((char const *)arg1,(char const *)arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBPlugin_List__SWIG_1(char * jarg1, char * jarg2) { char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ; arg1 = (char *)jarg1;  arg2 = (char *)jarg2; 
  OpenBabel::OBPlugin::List((char const *)arg1,(char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBPlugin_List__SWIG_2(char * jarg1) { char *arg1 = (char *) 0 ; arg1 = (char *)jarg1; 
  OpenBabel::OBPlugin::List((char const *)arg1); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_ListAsString__SWIG_0(char * jarg1, char * jarg2) { char * jresult ;
  char *arg1 = (char *) 0 ; char *arg2 = (char *) 0 ; std::string result; arg1 = (char *)jarg1;  arg2 = (char *)jarg2; 
  result = OpenBabel::OBPlugin::ListAsString((char const *)arg1,(char const *)arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_ListAsString__SWIG_1(char * jarg1) { char * jresult ; char *arg1 = (char *) 0 ;
  std::string result; arg1 = (char *)jarg1;  result = OpenBabel::OBPlugin::ListAsString((char const *)arg1);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBPlugin_FirstLine(char * jarg1) { char * jresult ; char *arg1 = (char *) 0 ;
  std::string result; arg1 = (char *)jarg1;  result = OpenBabel::OBPlugin::FirstLine((char const *)arg1);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_stringbuf() { void * jresult ; std::stringbuf *result = 0 ;
  result = (std::stringbuf *)new std::stringbuf(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_stringbuf(void * jarg1) { std::stringbuf *arg1 = (std::stringbuf *) 0 ;
  arg1 = (std::stringbuf *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_0(char * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5, int jarg6) {
  void * jresult ; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string *arg4 = 0 ;
  std::string *arg5 = 0 ; OpenBabel::obMessageLevel arg6 ; OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg4_str(jarg4); arg4 = &arg4_str;  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg5_str(jarg5); arg5 = &arg5_str;  arg6 = (OpenBabel::obMessageLevel)jarg6; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_1(char * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5) {
  void * jresult ; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string *arg4 = 0 ;
  std::string *arg5 = 0 ; OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg4_str(jarg4); arg4 = &arg4_str;  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg5_str(jarg5); arg5 = &arg5_str; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_2(char * jarg1, char * jarg2, char * jarg3, char * jarg4) {
  void * jresult ; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string *arg4 = 0 ;
  OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg4_str(jarg4); arg4 = &arg4_str; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_3(char * jarg1, char * jarg2, char * jarg3) { void * jresult ;
  std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_4(char * jarg1, char * jarg2) { void * jresult ; std::string *arg1 = 0 ;
  std::string *arg2 = 0 ; OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1,(std::string const &)*arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_5(char * jarg1) { void * jresult ; std::string *arg1 = 0 ;
  OpenBabel::OBError *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str; 
  result = (OpenBabel::OBError *)new OpenBabel::OBError((std::string const &)*arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBError__SWIG_6() { void * jresult ; OpenBabel::OBError *result = 0 ;
  result = (OpenBabel::OBError *)new OpenBabel::OBError(); jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_message(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->message(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_GetMethod(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->GetMethod(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_GetError(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->GetError(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_GetExplanation(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->GetExplanation(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_GetPossibleCause(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->GetPossibleCause(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBError_GetSuggestedRemedy(void * jarg1) { char * jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; std::string result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = ((OpenBabel::OBError const *)arg1)->GetSuggestedRemedy(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBError_GetLevel(void * jarg1) { int jresult ;
  OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ; OpenBabel::obMessageLevel result; arg1 = (OpenBabel::OBError *)jarg1; 
  result = (OpenBabel::obMessageLevel)((OpenBabel::OBError const *)arg1)->GetLevel(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBError(void * jarg1) { OpenBabel::OBError *arg1 = (OpenBabel::OBError *) 0 ;
  arg1 = (OpenBabel::OBError *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMessageHandler() { void * jresult ; OpenBabel::OBMessageHandler *result = 0 ;
  result = (OpenBabel::OBMessageHandler *)new OpenBabel::OBMessageHandler(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMessageHandler(void * jarg1) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ThrowError__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; OpenBabel::OBError arg2 ;
  OpenBabel::errorQualifier arg3 ; OpenBabel::OBError *argp2 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  argp2 = (OpenBabel::OBError *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::OBError", 0);
    return ; }  arg2 = *argp2;  arg3 = (OpenBabel::errorQualifier)jarg3;  (arg1)->ThrowError(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ThrowError__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; OpenBabel::OBError arg2 ; OpenBabel::OBError *argp2 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  argp2 = (OpenBabel::OBError *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::OBError", 0);
    return ; }  arg2 = *argp2;  (arg1)->ThrowError(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ThrowError__SWIG_2(void * jarg1, char * jarg2, char * jarg3, int jarg4, int jarg5) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ;
  OpenBabel::obMessageLevel arg4 ; OpenBabel::errorQualifier arg5 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  arg4 = (OpenBabel::obMessageLevel)jarg4; 
  arg5 = (OpenBabel::errorQualifier)jarg5; 
  (arg1)->ThrowError((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ThrowError__SWIG_3(void * jarg1, char * jarg2, char * jarg3, int jarg4) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ;
  OpenBabel::obMessageLevel arg4 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  arg4 = (OpenBabel::obMessageLevel)jarg4; 
  (arg1)->ThrowError((std::string const &)*arg2,(std::string const &)*arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ThrowError__SWIG_4(void * jarg1, char * jarg2, char * jarg3) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  (arg1)->ThrowError((std::string const &)*arg2,(std::string const &)*arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMessageHandler_GetMessagesOfLevel(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; OpenBabel::obMessageLevel arg2 ;
  std::vector< std::string > result; arg1 = (OpenBabel::OBMessageHandler *)jarg1;  arg2 = (OpenBabel::obMessageLevel)jarg2; 
  result = (arg1)->GetMessagesOfLevel(arg2);
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_StartLogging(void * jarg1) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  (arg1)->StartLogging(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_StopLogging(void * jarg1) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  (arg1)->StopLogging(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_SetMaxLogEntries(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  arg2 = (unsigned int)jarg2;  (arg1)->SetMaxLogEntries(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetMaxLogEntries(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetMaxLogEntries(); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_ClearLog(void * jarg1) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  (arg1)->ClearLog(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_SetOutputLevel(void * jarg1, int jarg2) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; OpenBabel::obMessageLevel arg2 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  arg2 = (OpenBabel::obMessageLevel)jarg2;  (arg1)->SetOutputLevel(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMessageHandler_GetOutputLevel(void * jarg1) { int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; OpenBabel::obMessageLevel result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (OpenBabel::obMessageLevel)(arg1)->GetOutputLevel(); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMessageHandler_SetOutputStream(void * jarg1, void * jarg2) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  arg2 = (std::ostream *)jarg2;  (arg1)->SetOutputStream(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMessageHandler_GetOutputStream(void * jarg1) { void * jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::ostream *result = 0 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (std::ostream *)(arg1)->GetOutputStream(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_StartErrorWrap(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; bool result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (bool)(arg1)->StartErrorWrap(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_StopErrorWrap(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; bool result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (bool)(arg1)->StopErrorWrap(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetErrorMessageCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetErrorMessageCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetWarningMessageCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetWarningMessageCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetInfoMessageCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetInfoMessageCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetAuditMessageCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetAuditMessageCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMessageHandler_GetDebugMessageCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (unsigned int)(arg1)->GetDebugMessageCount(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMessageHandler_GetMessageSummary(void * jarg1) { char * jresult ;
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; std::string result;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1;  result = (arg1)->GetMessageSummary();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_obErrorLog_set(void * jarg1) {
  OpenBabel::OBMessageHandler *arg1 = (OpenBabel::OBMessageHandler *) 0 ; arg1 = (OpenBabel::OBMessageHandler *)jarg1; 
  OpenBabel::obErrorLog = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_obErrorLog_get() { void * jresult ; OpenBabel::OBMessageHandler *result = 0 ;
  result = (OpenBabel::OBMessageHandler *)&OpenBabel::obErrorLog; jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFormat_Default() { void * jresult ; OpenBabel::OBFormat **result = 0 ;
  result = (OpenBabel::OBFormat **) &OpenBabel::OBFormat::Default(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFormat_FindType(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFormat *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFormat *)OpenBabel::OBFormat::FindType((char const *)arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_ReadMolecule(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBConversion *arg3 = (OpenBabel::OBConversion *) 0 ;
  bool result; arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (OpenBabel::OBConversion *)jarg3;  result = (bool)(arg1)->ReadMolecule(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_ReadChemObject(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; OpenBabel::OBConversion *arg2 = (OpenBabel::OBConversion *) 0 ;
  bool result; arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (OpenBabel::OBConversion *)jarg2; 
  result = (bool)(arg1)->ReadChemObject(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_WriteMolecule(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBConversion *arg3 = (OpenBabel::OBConversion *) 0 ;
  bool result; arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (OpenBabel::OBConversion *)jarg3;  result = (bool)(arg1)->WriteMolecule(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_WriteChemObject(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; OpenBabel::OBConversion *arg2 = (OpenBabel::OBConversion *) 0 ;
  bool result; arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (OpenBabel::OBConversion *)jarg2; 
  result = (bool)(arg1)->WriteChemObject(arg2); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFormat_TargetClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBFormat *)jarg1; 
  result = (char *)(arg1)->TargetClassDescription(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFormat_SpecificationURL(void * jarg1) { char * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBFormat *)jarg1; 
  result = (char *)(arg1)->SpecificationURL(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFormat_GetMIMEType(void * jarg1) { char * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBFormat *)jarg1; 
  result = (char *)(arg1)->GetMIMEType(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_Flags(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; unsigned int result; arg1 = (OpenBabel::OBFormat *)jarg1; 
  result = (unsigned int)(arg1)->Flags(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFormat_SkipObjects(void * jarg1, int jarg2, void * jarg3) { int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; int arg2 ;
  OpenBabel::OBConversion *arg3 = (OpenBabel::OBConversion *) 0 ; int result; arg1 = (OpenBabel::OBFormat *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBConversion *)jarg3;  result = (int)(arg1)->SkipObjects(arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFormat_MakeNewInstance(void * jarg1) { void * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; OpenBabel::OBFormat *result = 0 ;
  arg1 = (OpenBabel::OBFormat *)jarg1;  result = (OpenBabel::OBFormat *)(arg1)->MakeNewInstance(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFormat_RegisterFormat__SWIG_0(void * jarg1, char * jarg2, char * jarg3) { int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; int result;
  arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (char *)jarg2;  arg3 = (char *)jarg3; 
  result = (int)(arg1)->RegisterFormat((char const *)arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFormat_RegisterFormat__SWIG_1(void * jarg1, char * jarg2) { int jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *arg2 = (char *) 0 ; int result;
  arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (char *)jarg2;  result = (int)(arg1)->RegisterFormat((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_Display__SWIG_0(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
  unsigned int jresult ; OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; char *arg4 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBFormat *)jarg1; 
  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  arg4 = (char *)jarg4;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3,(char const *)arg4);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFormat_Display__SWIG_1(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBFormat *)jarg1;  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFormat_FormatFromMIME(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFormat *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFormat *)OpenBabel::OBFormat::FormatFromMIME((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFormat(void * jarg1) { OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ;
  arg1 = (OpenBabel::OBFormat *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConversion__SWIG_0(void * jarg1, void * jarg2) { void * jresult ;
  std::istream *arg1 = (std::istream *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ; OpenBabel::OBConversion *result = 0 ;
  arg1 = (std::istream *)jarg1;  arg2 = (std::ostream *)jarg2; 
  result = (OpenBabel::OBConversion *)new OpenBabel::OBConversion(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConversion__SWIG_1(void * jarg1) { void * jresult ;
  std::istream *arg1 = (std::istream *) 0 ; OpenBabel::OBConversion *result = 0 ; arg1 = (std::istream *)jarg1; 
  result = (OpenBabel::OBConversion *)new OpenBabel::OBConversion(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConversion__SWIG_2() { void * jresult ; OpenBabel::OBConversion *result = 0 ;
  result = (OpenBabel::OBConversion *)new OpenBabel::OBConversion(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBConversion__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = 0 ; OpenBabel::OBConversion *result = 0 ; arg1 = (OpenBabel::OBConversion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBConversion const & type is null", 0);
    return 0; }   result = (OpenBabel::OBConversion *)new OpenBabel::OBConversion((OpenBabel::OBConversion const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBConversion(void * jarg1) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1;  delete arg1; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_RegisterFormat__SWIG_0(char * jarg1, void * jarg2, char * jarg3) { int jresult ;
  char *arg1 = (char *) 0 ; OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; char *arg3 = (char *) 0 ; int result;
  arg1 = (char *)jarg1;  arg2 = (OpenBabel::OBFormat *)jarg2;  arg3 = (char *)jarg3; 
  result = (int)OpenBabel::OBConversion::RegisterFormat((char const *)arg1,arg2,(char const *)arg3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_RegisterFormat__SWIG_1(char * jarg1, void * jarg2) { int jresult ;
  char *arg1 = (char *) 0 ; OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; int result; arg1 = (char *)jarg1; 
  arg2 = (OpenBabel::OBFormat *)jarg2;  result = (int)OpenBabel::OBConversion::RegisterFormat((char const *)arg1,arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_FindFormat__SWIG_0(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFormat *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFormat *)OpenBabel::OBConversion::FindFormat((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_FormatFromExt__SWIG_0(char * jarg1) { void * jresult ;
  char *arg1 = (char *) 0 ; OpenBabel::OBFormat *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFormat *)OpenBabel::OBConversion::FormatFromExt((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_FormatFromMIME(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFormat *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFormat *)OpenBabel::OBConversion::FormatFromMIME((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_Description() { char * jresult ; char *result = 0 ;
  result = (char *)OpenBabel::OBConversion::Description(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetInStream(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::istream *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = (std::istream *)((OpenBabel::OBConversion const *)arg1)->GetInStream();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetOutStream(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::ostream *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = (std::ostream *)((OpenBabel::OBConversion const *)arg1)->GetOutStream();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetInStream(void * jarg1, void * jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::istream *arg2 = (std::istream *) 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (std::istream *)jarg2;  (arg1)->SetInStream(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetOutStream(void * jarg1, void * jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (std::ostream *)jarg2;  (arg1)->SetOutStream(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetInAndOutFormats__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2;  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->SetInAndOutFormats((char const *)arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetInAndOutFormats__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; OpenBabel::OBFormat *arg3 = (OpenBabel::OBFormat *) 0 ; bool result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBFormat *)jarg2;  arg3 = (OpenBabel::OBFormat *)jarg3; 
  result = (bool)(arg1)->SetInAndOutFormats(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetInFormat__SWIG_0(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(arg1)->SetInFormat((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetInFormat__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ;
  bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBFormat *)jarg2; 
  result = (bool)(arg1)->SetInFormat(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetOutFormat__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(arg1)->SetOutFormat((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_SetOutFormat__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBFormat *)jarg2;  result = (bool)(arg1)->SetOutFormat(arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetInFormat(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBFormat *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (OpenBabel::OBFormat *)((OpenBabel::OBConversion const *)arg1)->GetInFormat(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetOutFormat(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBFormat *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (OpenBabel::OBFormat *)((OpenBabel::OBConversion const *)arg1)->GetOutFormat(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_GetInFilename(void * jarg1) { char * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::string result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = ((OpenBabel::OBConversion const *)arg1)->GetInFilename(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBConversion_GetInLen(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; size_t result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = ((OpenBabel::OBConversion const *)arg1)->GetInLen(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_GetTitle(void * jarg1) { char * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (char *)((OpenBabel::OBConversion const *)arg1)->GetTitle();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetAuxConv(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBConversion *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (OpenBabel::OBConversion *)((OpenBabel::OBConversion const *)arg1)->GetAuxConv(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetAuxConv(void * jarg1, void * jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBConversion *arg2 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBConversion *)jarg2;  (arg1)->SetAuxConv(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_IsOption__SWIG_0(void * jarg1, char * jarg2, int jarg3) { char * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  OpenBabel::OBConversion::Option_type arg3 ; char *result = 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (char *)jarg2;  arg3 = (OpenBabel::OBConversion::Option_type)jarg3; 
  result = (char *)(arg1)->IsOption((char const *)arg2,arg3); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_IsOption__SWIG_1(void * jarg1, char * jarg2) { char * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2;  result = (char *)(arg1)->IsOption((char const *)arg2);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_AddOption__SWIG_0(void * jarg1, char * jarg2, int jarg3, char * jarg4) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  OpenBabel::OBConversion::Option_type arg3 ; char *arg4 = (char *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (char *)jarg2;  arg3 = (OpenBabel::OBConversion::Option_type)jarg3;  arg4 = (char *)jarg4; 
  (arg1)->AddOption((char const *)arg2,arg3,(char const *)arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_AddOption__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  OpenBabel::OBConversion::Option_type arg3 ; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2; 
  arg3 = (OpenBabel::OBConversion::Option_type)jarg3;  (arg1)->AddOption((char const *)arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_AddOption__SWIG_2(void * jarg1, char * jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2;  (arg1)->AddOption((char const *)arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_RemoveOption(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  OpenBabel::OBConversion::Option_type arg3 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2; 
  arg3 = (OpenBabel::OBConversion::Option_type)jarg3;  result = (bool)(arg1)->RemoveOption((char const *)arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetOptions(void * jarg1, char * jarg2, int jarg3) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; char *arg2 = (char *) 0 ;
  OpenBabel::OBConversion::Option_type arg3 ; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (char *)jarg2; 
  arg3 = (OpenBabel::OBConversion::Option_type)jarg3;  (arg1)->SetOptions((char const *)arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_RegisterOptionParam__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4) {
  std::string arg1 ; OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; int arg3 ;
  OpenBabel::OBConversion::Option_type arg4 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg1)->assign(jarg1);  arg2 = (OpenBabel::OBFormat *)jarg2;  arg3 = (int)jarg3; 
  arg4 = (OpenBabel::OBConversion::Option_type)jarg4;  OpenBabel::OBConversion::RegisterOptionParam(arg1,arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_RegisterOptionParam__SWIG_1(char * jarg1, void * jarg2, int jarg3) {
  std::string arg1 ; OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; int arg3 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg1)->assign(jarg1);  arg2 = (OpenBabel::OBFormat *)jarg2;  arg3 = (int)jarg3; 
  OpenBabel::OBConversion::RegisterOptionParam(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_RegisterOptionParam__SWIG_2(char * jarg1, void * jarg2) { std::string arg1 ;
  OpenBabel::OBFormat *arg2 = (OpenBabel::OBFormat *) 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg1)->assign(jarg1);  arg2 = (OpenBabel::OBFormat *)jarg2;  OpenBabel::OBConversion::RegisterOptionParam(arg1,arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_GetOptionParams(char * jarg1, int jarg2) { int jresult ; std::string arg1 ;
  OpenBabel::OBConversion::Option_type arg2 ; int result; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg1)->assign(jarg1);  arg2 = (OpenBabel::OBConversion::Option_type)jarg2; 
  result = (int)OpenBabel::OBConversion::GetOptionParams(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_CopyOptions__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBConversion *arg2 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBConversion::Option_type arg3 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBConversion *)jarg2; 
  arg3 = (OpenBabel::OBConversion::Option_type)jarg3;  (arg1)->CopyOptions(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_CopyOptions__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBConversion *arg2 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBConversion *)jarg2;  (arg1)->CopyOptions(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetSupportedInputFormat(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::vector< std::string > result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = (arg1)->GetSupportedInputFormat();
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetSupportedOutputFormat(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::vector< std::string > result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = (arg1)->GetSupportedOutputFormat();
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result);  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_Convert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::istream *arg2 = (std::istream *) 0 ;
  std::ostream *arg3 = (std::ostream *) 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (std::istream *)jarg2; 
  arg3 = (std::ostream *)jarg3;  result = (int)(arg1)->Convert(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_Convert__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (int)(arg1)->Convert(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_FullConvert(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ; std::vector< std::string > *arg4 = 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > & type is null", 0);
    return 0; }   arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg4 = (std::vector< std::string > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > & type is null", 0);
    return 0; }   result = (int)(arg1)->FullConvert(*arg2,*arg3,*arg4); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_AddChemObject(void * jarg1, void * jarg2) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  int result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (int)(arg1)->AddChemObject(arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetChemObject(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = (OpenBabel::OBBase *)(arg1)->GetChemObject(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_IsLast(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (bool)(arg1)->IsLast(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_IsFirstInput(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (bool)(arg1)->IsFirstInput(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetFirstInput__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetFirstInput(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetFirstInput__SWIG_1(void * jarg1) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  (arg1)->SetFirstInput(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_GetOutputIndex(void * jarg1) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (int)((OpenBabel::OBConversion const *)arg1)->GetOutputIndex(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetOutputIndex(void * jarg1, int jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int arg2 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetOutputIndex(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetMoreFilesToCome(void * jarg1) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  (arg1)->SetMoreFilesToCome(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetOneObjectOnly__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetOneObjectOnly(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetOneObjectOnly__SWIG_1(void * jarg1) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  (arg1)->SetOneObjectOnly(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_SetLast(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetLast(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_IsLastFile(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (bool)(arg1)->IsLastFile(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_GetCount(void * jarg1) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (int)((OpenBabel::OBConversion const *)arg1)->GetCount(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBConversion_GetDefaultFormat() { void * jresult ; OpenBabel::OBFormat *result = 0 ;
  result = (OpenBabel::OBFormat *)OpenBabel::OBConversion::GetDefaultFormat(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_Write__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::ostream *arg3 = (std::ostream *) 0 ; bool result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::ostream *)jarg3; 
  result = (bool)(arg1)->Write(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_Write__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  result = (bool)(arg1)->Write(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_WriteString__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  char * jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; bool arg3 ; std::string result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = jarg3 ? true : false;  result = (arg1)->WriteString(arg2,arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBConversion_WriteString__SWIG_1(void * jarg1, void * jarg2) { char * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  std::string result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (arg1)->WriteString(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_WriteFile(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string arg3 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg3)->assign(jarg3);  result = (bool)(arg1)->WriteFile(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_CloseOutFile(void * jarg1) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  (arg1)->CloseOutFile(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_Read__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::istream *arg3 = (std::istream *) 0 ; bool result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::istream *)jarg3; 
  result = (bool)(arg1)->Read(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_Read__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  result = (bool)(arg1)->Read(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_ReadString(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string arg3 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg3)->assign(jarg3);  result = (bool)(arg1)->ReadString(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_ReadFile(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string arg3 ; bool result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg3)->assign(jarg3);  result = (bool)(arg1)->ReadFile(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBConversion_OpenInAndOutFiles(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::string arg2 ; std::string arg3 ;
  bool result; arg1 = (OpenBabel::OBConversion *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg2)->assign(jarg2);  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg3)->assign(jarg3);  result = (bool)(arg1)->OpenInAndOutFiles(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_ReportNumberConverted__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int arg2 ;
  OpenBabel::OBFormat *arg3 = (OpenBabel::OBFormat *) 0 ; arg1 = (OpenBabel::OBConversion *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (OpenBabel::OBFormat *)jarg3;  (arg1)->ReportNumberConverted(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBConversion_ReportNumberConverted__SWIG_1(void * jarg1, int jarg2) {
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int arg2 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->ReportNumberConverted(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBConversion_NumInputObjects(void * jarg1) { int jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; int result; arg1 = (OpenBabel::OBConversion *)jarg1; 
  result = (int)(arg1)->NumInputObjects(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidue__SWIG_0() { void * jresult ; OpenBabel::OBResidue *result = 0 ;
  result = (OpenBabel::OBResidue *)new OpenBabel::OBResidue(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidue__SWIG_1(void * jarg1) { void * jresult ; OpenBabel::OBResidue *arg1 = 0 ;
  OpenBabel::OBResidue *result = 0 ; arg1 = (OpenBabel::OBResidue *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue const & type is null", 0);
    return 0; }   result = (OpenBabel::OBResidue *)new OpenBabel::OBResidue((OpenBabel::OBResidue const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBResidue(void * jarg1) { OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_AddAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->AddAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_InsertAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->InsertAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_RemoveAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->RemoveAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetName(void * jarg1, char * jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetName((std::string const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetNum__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetNum__SWIG_1(void * jarg1, char * jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::string arg2 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetChain(void * jarg1, char jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; char arg2 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (char)jarg2;  (arg1)->SetChain(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetChainNum(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetChainNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetIdx(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetAtomID(void * jarg1, void * jarg2, char * jarg3) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  std::string *arg3 = 0 ; arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  (arg1)->SetAtomID(arg2,(std::string const &)*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetHetAtom(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool arg3 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = jarg3 ? true : false; 
  (arg1)->SetHetAtom(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidue_SetSerialNum(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int arg3 ; arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->SetSerialNum(arg2,arg3); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidue_GetName(void * jarg1) { char * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::string result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = ((OpenBabel::OBResidue const *)arg1)->GetName(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (unsigned int)(arg1)->GetNum(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidue_GetNumString(void * jarg1) { char * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::string result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (arg1)->GetNumString(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetNumAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (unsigned int)((OpenBabel::OBResidue const *)arg1)->GetNumAtoms(); jresult = result;  return jresult; }
SWIGEXPORT char SWIGSTDCALL CSharp_OBResidue_GetChain(void * jarg1) { char jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; char result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (char)((OpenBabel::OBResidue const *)arg1)->GetChain(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetChainNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (unsigned int)((OpenBabel::OBResidue const *)arg1)->GetChainNum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (unsigned int)((OpenBabel::OBResidue const *)arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetResKey(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (unsigned int)((OpenBabel::OBResidue const *)arg1)->GetResKey(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_GetAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::vector< OpenBabel::OBAtom * > result;
  arg1 = (OpenBabel::OBResidue *)jarg1;  result = ((OpenBabel::OBResidue const *)arg1)->GetAtoms();
  jresult = new std::vector< OpenBabel::OBAtom * >((const std::vector< OpenBabel::OBAtom * > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_GetBonds__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; bool arg2 ; std::vector< OpenBabel::OBBond * > result;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = jarg2 ? true : false; 
  result = ((OpenBabel::OBResidue const *)arg1)->GetBonds(arg2);
  jresult = new std::vector< OpenBabel::OBBond * >((const std::vector< OpenBabel::OBBond * > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_GetBonds__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::vector< OpenBabel::OBBond * > result;
  arg1 = (OpenBabel::OBResidue *)jarg1;  result = ((OpenBabel::OBResidue const *)arg1)->GetBonds();
  jresult = new std::vector< OpenBabel::OBBond * >((const std::vector< OpenBabel::OBBond * > &)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidue_GetAtomID(void * jarg1, void * jarg2) { char * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  std::string result; arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = ((OpenBabel::OBResidue const *)arg1)->GetAtomID(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetSerialNum(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int result; arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (unsigned int)((OpenBabel::OBResidue const *)arg1)->GetSerialNum(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetAminoAcidProperty(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)((OpenBabel::OBResidue const *)arg1)->GetAminoAcidProperty(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetAtomProperty(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ; OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; int arg3 ; bool result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (int)jarg3; 
  result = (bool)((OpenBabel::OBResidue const *)arg1)->GetAtomProperty(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_GetResidueProperty(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)((OpenBabel::OBResidue const *)arg1)->GetResidueProperty(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_IsHetAtom(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidue *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)((OpenBabel::OBResidue const *)arg1)->IsHetAtom(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidue_IsResidueType(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)((OpenBabel::OBResidue const *)arg1)->IsResidueType(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__a_set(void * jarg1, void * jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->_a = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBInternalCoord__a_get(void * jarg1) { void * jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->_a); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__b_set(void * jarg1, void * jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->_b = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBInternalCoord__b_get(void * jarg1) { void * jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->_b); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__c_set(void * jarg1, void * jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->_c = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBInternalCoord__c_get(void * jarg1) { void * jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->_c); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__dst_set(void * jarg1, double jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (double)jarg2;  if (arg1) (arg1)->_dst = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBInternalCoord__dst_get(void * jarg1) { double jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double result;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (double) ((arg1)->_dst); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__ang_set(void * jarg1, double jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (double)jarg2;  if (arg1) (arg1)->_ang = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBInternalCoord__ang_get(void * jarg1) { double jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double result;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (double) ((arg1)->_ang); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBInternalCoord__tor_set(void * jarg1, double jarg2) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  arg2 = (double)jarg2;  if (arg1) (arg1)->_tor = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBInternalCoord__tor_get(void * jarg1) { double jresult ;
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; double result;
  arg1 = (OpenBabel::OBInternalCoord *)jarg1;  result = (double) ((arg1)->_tor); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double arg4 ; double arg5 ; double arg6 ;
  OpenBabel::OBInternalCoord *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  arg3 = (OpenBabel::OBAtom *)jarg3;  arg4 = (double)jarg4;  arg5 = (double)jarg5;  arg6 = (double)jarg6; 
  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1,arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double arg4 ; double arg5 ; OpenBabel::OBInternalCoord *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (double)jarg4;  arg5 = (double)jarg5; 
  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1,arg2,arg3,arg4,arg5); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_2(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double arg4 ; OpenBabel::OBInternalCoord *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (double)jarg4;  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1,arg2,arg3,arg4);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_3(void * jarg1, void * jarg2, void * jarg3) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBInternalCoord *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1,arg2,arg3); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_4(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBInternalCoord *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_5(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBInternalCoord *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBInternalCoord__SWIG_6() { void * jresult ; OpenBabel::OBInternalCoord *result = 0 ;
  result = (OpenBabel::OBInternalCoord *)new OpenBabel::OBInternalCoord(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBInternalCoord(void * jarg1) {
  OpenBabel::OBInternalCoord *arg1 = (OpenBabel::OBInternalCoord *) 0 ; arg1 = (OpenBabel::OBInternalCoord *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool) ((arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtom() { void * jresult ; OpenBabel::OBAtom *result = 0 ;
  result = (OpenBabel::OBAtom *)new OpenBabel::OBAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAtom(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetIdx(void * jarg1, int jarg2) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (int)jarg2;  (arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetId(void * jarg1, unsigned long jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned long arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (unsigned long)jarg2;  (arg1)->SetId(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetHyb(void * jarg1, int jarg2) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (int)jarg2;  (arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; short arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (short)jarg2; 
  (arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetAtomType(void * jarg1, char * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetType(void * jarg1, char * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetType((std::string const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double arg2 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (double)jarg2; 
  (arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *arg2 = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->SetVector((OpenBabel::vector3 const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetVector__SWIG_2(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetAromatic(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_UnsetAromatic(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetClockwiseStereo(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetPositiveStereo(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetNegativeStereo(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_UnsetStereo(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetInRing(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_SetChiral(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->SetChiral(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtom_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (int)((OpenBabel::OBAtom const *)arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetAtomicNum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBAtom_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned short result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned short)((OpenBabel::OBAtom const *)arg1)->GetIsotope(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtom_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (int)((OpenBabel::OBAtom const *)arg1)->GetSpinMultiplicity(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetIndex(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetIndex(); jresult = result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBAtom_GetId(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned long result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned long)((OpenBabel::OBAtom const *)arg1)->GetId(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetCoordinateIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetValence(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetImplicitValence(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetHvyValence(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->GetHeteroValence(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBAtom_GetAtomType(void * jarg1) { char * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (char *)(arg1)->GetType(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_x(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_y(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_z(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)((OpenBabel::OBAtom const *)arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double *)(arg1)->GetCoordinate(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (OpenBabel::vector3 *) &(arg1)->GetVector(); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)(arg1)->GetPartialCharge(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBResidue *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (OpenBabel::OBResidue *)(arg1)->GetResidue(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = jarg2 ? true : false;  result = (OpenBabel::OBResidue *)(arg1)->GetResidue(arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBMol *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (OpenBabel::OBMol *)(arg1)->GetParent(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *arg2 = 0 ; double arg3 ;
  bool result; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (double)jarg3;  result = (bool)(arg1)->GetNewBondVector(*arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (OpenBabel::OBAtom *)(arg1)->GetNextAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (int)jarg2;  result = (double)(arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (double)(arg1)->GetDistance(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; int arg3 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (int)jarg3;  result = (double)(arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3;  result = (double)(arg1)->GetAngle(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_NewResidue(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_DeleteResidue(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (arg1)->AddBond(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; bool result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  result = (bool)(arg1)->DeleteBond(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_ClearBond(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)(arg1)->SetHybAndGeom(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_ForceNoH(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtom_ForceImplH(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->CountFreeOxygens(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->ImplicitHydrogenCount(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool arg2 ; unsigned int result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_ExplicitHydrogenCount__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->ExplicitHydrogenCount(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->MemberOfRingCount(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->MemberOfRingSize(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->CountRingBonds(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)(arg1)->SmallestBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtom_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (double)(arg1)->AverageBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAtom const *)arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsHydrogen__SWIG_0(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)((OpenBabel::OBAtom const *)arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)((OpenBabel::OBAtom const *)arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)((OpenBabel::OBAtom const *)arg1)->IsInRingSize(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->IsConnected(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->IsOneThree(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->IsOneFour(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsPhosphateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsNonPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasChiralitySpecified(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasAlphaBetaUnsat(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasBondOfOrder(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int arg2 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (bool)(arg1)->HasBondOfOrder(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtom_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; unsigned int arg2 ; int result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (int)(arg1)->CountBondsOfOrder(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = (bool)(arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtom_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; char *arg2 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (char *)jarg2;  result = (bool)(arg1)->MatchesSMARTS((char const *)arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool) ((arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBond() { void * jresult ; OpenBabel::OBBond *result = 0 ;
  result = (OpenBabel::OBBond *)new OpenBabel::OBBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBBond(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetIdx(void * jarg1, int jarg2) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (int)jarg2;  (arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetId(void * jarg1, unsigned long jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned long arg2 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  arg2 = (unsigned long)jarg2;  (arg1)->SetId(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetBO(void * jarg1, int jarg2) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (int)jarg2;  (arg1)->SetBO(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetBondOrder(void * jarg1, int jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; int arg2 ; arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetBondOrder(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetBegin(void * jarg1, void * jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->SetBegin(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetEnd(void * jarg1, void * jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->SetEnd(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetLength__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; double arg3 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (double)jarg3;  (arg1)->SetLength(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetLength__SWIG_1(void * jarg1, double jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; double arg2 ; arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (double)jarg2; 
  (arg1)->SetLength(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_Set(void * jarg1, int jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; int arg2 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ; int arg5 ; int arg6 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3;  arg4 = (OpenBabel::OBAtom *)jarg4;  arg5 = (int)jarg5; 
  arg6 = (int)jarg6;  (arg1)->Set(arg2,arg3,arg4,arg5,arg6); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetKSingle(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetKSingle(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetKDouble(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetKDouble(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetKTriple(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetKTriple(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetAromatic(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetWedge(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetHash(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetWedgeOrHash(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetWedgeOrHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetUp(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetDown(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetInRing__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->SetInRing(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetInRing__SWIG_1(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_SetClosure(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetClosure(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetHash(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetWedge(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetUp(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetDown(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetAromatic(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBond_UnsetKekule(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->UnsetKekule(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBBond_GetId(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned long result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned long)((OpenBabel::OBBond const *)arg1)->GetId(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetBO(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetBO(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetBondOrder(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetBondOrder(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetFlags(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetFlags(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetBeginAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetBeginAtomIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetEndAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBond const *)arg1)->GetEndAtomIdx(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBond_GetBeginAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (OpenBabel::OBAtom *)(arg1)->GetBeginAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBond_GetEndAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (OpenBabel::OBAtom *)(arg1)->GetEndAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBond_GetNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBAtom *)(arg1)->GetNbrAtom(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBond_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBMol *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (OpenBabel::OBMol *)(arg1)->GetParent(); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBBond_GetEquibLength(void * jarg1) { double jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; double result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (double)((OpenBabel::OBBond const *)arg1)->GetEquibLength(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBBond_GetLength(void * jarg1) { double jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; double result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (double)((OpenBabel::OBBond const *)arg1)->GetLength(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_GetNbrAtomIdx(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBBond *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (unsigned int)(arg1)->GetNbrAtomIdx(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBond_FindSmallestRing(void * jarg1) { void * jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; OpenBabel::OBRing *result = 0 ; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (OpenBabel::OBRing *)((OpenBabel::OBBond const *)arg1)->FindSmallestRing(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)((OpenBabel::OBBond const *)arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)((OpenBabel::OBBond const *)arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsRotor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsRotor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsPrimaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsPrimaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsSecondaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsSecondaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsTertiaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsTertiaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsEster(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsEster(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsCarbonyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsCarbonyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsKSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsKSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsKDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsKDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsKTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsKTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsClosure(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsClosure(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsUp(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsUp(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsDown(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsDown(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsWedge(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsWedge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsHash(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsHash(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsWedgeOrHash(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)((OpenBabel::OBBond const *)arg1)->IsWedgeOrHash(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsCisOrTrans(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)((OpenBabel::OBBond const *)arg1)->IsCisOrTrans(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBond_IsDoubleBondGeometry(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ; bool result; arg1 = (OpenBabel::OBBond *)jarg1; 
  result = (bool)(arg1)->IsDoubleBondGeometry(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMol__SWIG_0() { void * jresult ; OpenBabel::OBMol *result = 0 ;
  result = (OpenBabel::OBMol *)new OpenBabel::OBMol(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMol__SWIG_1(void * jarg1) { void * jresult ; OpenBabel::OBMol *arg1 = 0 ;
  OpenBabel::OBMol *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMol *)new OpenBabel::OBMol((OpenBabel::OBMol const &)*arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMol(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_ReserveAtoms(void * jarg1, int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->ReserveAtoms(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_CreateAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBAtom *)(arg1)->CreateAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_CreateBond(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBBond *)(arg1)->CreateBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_CreateResidue(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidue *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBResidue *)(arg1)->CreateResidue(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_DestroyAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->DestroyAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_DestroyBond(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (arg1)->DestroyBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_DestroyResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (arg1)->DestroyResidue(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddAtom(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtom & type is null", 0); return 0; }
    result = (bool)(arg1)->AddAtom(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_InsertAtom(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtom & type is null", 0); return 0; }
    result = (bool)(arg1)->InsertAtom(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddBond__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ;
  int arg6 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  arg5 = (int)jarg5;  arg6 = (int)jarg6;  result = (bool)(arg1)->AddBond(arg2,arg3,arg4,arg5,arg6); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddBond__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ;
  bool result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  arg5 = (int)jarg5;  result = (bool)(arg1)->AddBond(arg2,arg3,arg4,arg5); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddBond__SWIG_2(void * jarg1, int jarg2, int jarg3, int jarg4) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; int arg3 ; int arg4 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  result = (bool)(arg1)->AddBond(arg2,arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddBond__SWIG_3(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBond & type is null", 0); return 0; }
    result = (bool)(arg1)->AddBond(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddResidue(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidue *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidue & type is null", 0);
    return 0; }   result = (bool)(arg1)->AddResidue(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NewAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBAtom *)(arg1)->NewAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NewAtom__SWIG_1(void * jarg1, unsigned long jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned long arg2 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (unsigned long)jarg2;  result = (OpenBabel::OBAtom *)(arg1)->NewAtom(arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NewBond__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBBond *)(arg1)->NewBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NewBond__SWIG_1(void * jarg1, unsigned long jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned long arg2 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (unsigned long)jarg2;  result = (OpenBabel::OBBond *)(arg1)->NewBond(arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NewResidue(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidue *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBResidue *)(arg1)->NewResidue(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteAtom__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool arg3 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->DeleteAtom(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteAtom__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->DeleteAtom(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteBond__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool arg3 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->DeleteBond(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteBond__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  result = (bool)(arg1)->DeleteBond(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteResidue__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; bool arg3 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  arg3 = jarg3 ? true : false;  result = (bool)(arg1)->DeleteResidue(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteResidue__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  result = (bool)(arg1)->DeleteResidue(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_BeginModify(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->BeginModify(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_EndModify__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false; 
  (arg1)->EndModify(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_EndModify__SWIG_1(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->EndModify(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMol_GetMod(void * jarg1) { int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  int result; arg1 = (OpenBabel::OBMol *)jarg1;  result = (int)(arg1)->GetMod(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_IncrementMod(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->IncrementMod(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_DecrementMod(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->DecrementMod(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMol_GetFlags(void * jarg1) { int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  int result; arg1 = (OpenBabel::OBMol *)jarg1;  result = (int)(arg1)->GetFlags(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetTitle__SWIG_0(void * jarg1, unsigned int jarg2) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; char *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (char *)((OpenBabel::OBMol const *)arg1)->GetTitle(arg2);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetTitle__SWIG_1(void * jarg1) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (char *)((OpenBabel::OBMol const *)arg1)->GetTitle(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_NumAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)((OpenBabel::OBMol const *)arg1)->NumAtoms(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_NumBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)((OpenBabel::OBMol const *)arg1)->NumBonds(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_NumHvyAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)(arg1)->NumHvyAtoms(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_NumResidues(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)((OpenBabel::OBMol const *)arg1)->NumResidues(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_NumRotors(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)(arg1)->NumRotors(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetAtom(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBAtom *)((OpenBabel::OBMol const *)arg1)->GetAtom(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetAtomById(void * jarg1, unsigned long jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned long arg2 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (unsigned long)jarg2; 
  result = (OpenBabel::OBAtom *)((OpenBabel::OBMol const *)arg1)->GetAtomById(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetFirstAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBAtom *)((OpenBabel::OBMol const *)arg1)->GetFirstAtom(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetBond__SWIG_0(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBBond *)((OpenBabel::OBMol const *)arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetBondById(void * jarg1, unsigned long jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned long arg2 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (unsigned long)jarg2; 
  result = (OpenBabel::OBBond *)((OpenBabel::OBMol const *)arg1)->GetBondById(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetBond__SWIG_1(void * jarg1, int jarg2, int jarg3) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; int arg3 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (OpenBabel::OBBond *)((OpenBabel::OBMol const *)arg1)->GetBond(arg2,arg3); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetBond__SWIG_2(void * jarg1, void * jarg2, void * jarg3) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (OpenBabel::OBBond *)((OpenBabel::OBMol const *)arg1)->GetBond(arg2,arg3); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetResidue(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBResidue *)((OpenBabel::OBMol const *)arg1)->GetResidue(arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetInternalCoord(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBInternalCoord * > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->GetInternalCoord();
  jresult = new std::vector< OpenBabel::OBInternalCoord * >((const std::vector< OpenBabel::OBInternalCoord * > &)result); 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetTorsion__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
  double jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; double result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4;  arg5 = (int)jarg5; 
  result = (double)(arg1)->GetTorsion(arg2,arg3,arg4,arg5); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetTorsion__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  double jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg5 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3;  arg4 = (OpenBabel::OBAtom *)jarg4; 
  arg5 = (OpenBabel::OBAtom *)jarg5;  result = (double)(arg1)->GetTorsion(arg2,arg3,arg4,arg5); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetAngle(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (OpenBabel::OBAtom *)jarg4;  result = (double)(arg1)->GetAngle(arg2,arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetFormula(void * jarg1) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::string result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (arg1)->GetFormula(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetSpacedFormula__SWIG_0(void * jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
  char * jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; char *arg3 = (char *) 0 ; bool arg4 ;
  std::string result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (char *)jarg3; 
  arg4 = jarg4 ? true : false;  result = (arg1)->GetSpacedFormula(arg2,(char const *)arg3,arg4);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetSpacedFormula__SWIG_1(void * jarg1, int jarg2, char * jarg3) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; char *arg3 = (char *) 0 ; std::string result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  arg3 = (char *)jarg3; 
  result = (arg1)->GetSpacedFormula(arg2,(char const *)arg3); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetSpacedFormula__SWIG_2(void * jarg1, int jarg2) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; std::string result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  result = (arg1)->GetSpacedFormula(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_GetSpacedFormula__SWIG_3(void * jarg1) { char * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::string result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (arg1)->GetSpacedFormula(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetEnergy__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (double)((OpenBabel::OBMol const *)arg1)->GetEnergy(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetMolWt__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (double)(arg1)->GetMolWt(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetMolWt__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (double)(arg1)->GetMolWt(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetExactMass__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (double)(arg1)->GetExactMass(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetExactMass__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (double)(arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMol_GetTotalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (int)(arg1)->GetTotalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_GetTotalSpinMultiplicity(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned int)(arg1)->GetTotalSpinMultiplicity(); jresult = result;  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBMol_GetDimension(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned short result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (unsigned short)((OpenBabel::OBMol const *)arg1)->GetDimension(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetCoordinates(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (double *)(arg1)->GetCoordinates(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetSSSR(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (std::vector< OpenBabel::OBRing * > *) &(arg1)->GetSSSR();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetLSSR(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (std::vector< OpenBabel::OBRing * > *) &(arg1)->GetLSSR();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AutomaticFormalCharge(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->AutomaticFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AutomaticPartialCharge(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->AutomaticPartialCharge(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetFormula(void * jarg1, char * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::string arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetFormula(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetEnergy(void * jarg1, double jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (double)jarg2; 
  (arg1)->SetEnergy(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetDimension(void * jarg1, unsigned short jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned short arg2 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (unsigned short)jarg2;  (arg1)->SetDimension(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetTotalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetTotalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetTotalSpinMultiplicity(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetTotalSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetInternalCoord(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBInternalCoord * > arg2 ;
  std::vector< OpenBabel::OBInternalCoord * > *argp2 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  argp2 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< OpenBabel::OBInternalCoord * >", 0);
    return ; }  arg2 = *argp2;  (arg1)->SetInternalCoord(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetAutomaticFormalCharge(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false; 
  (arg1)->SetAutomaticFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetAutomaticPartialCharge(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false; 
  (arg1)->SetAutomaticPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetAromaticPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetAromaticPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetSSSRPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetSSSRPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetLSSRPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetLSSRPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetRingAtomsAndBondsPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetRingAtomsAndBondsPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetAtomTypesPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetAtomTypesPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetRingTypesPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetRingTypesPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetChainsPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetChainsPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetChiralityPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetChiralityPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetPartialChargesPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetPartialChargesPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetHybridizationPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetHybridizationPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetImplicitValencePerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetImplicitValencePerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetKekulePerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetKekulePerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetClosureBondsPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetClosureBondsPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetHydrogensAdded(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetHydrogensAdded(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetCorrectedForPH(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetCorrectedForPH(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetAromaticCorrected(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetAromaticCorrected(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetSpinMultiplicityAssigned(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetSpinMultiplicityAssigned(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetFlags(void * jarg1, int jarg2) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  (arg1)->SetFlags(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetAromaticPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetAromaticPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetSSSRPerceived(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetSSSRPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetRingTypesPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetRingTypesPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetPartialChargesPerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetPartialChargesPerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetImplicitValencePerceived(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetImplicitValencePerceived(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetHydrogensAdded(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->UnsetHydrogensAdded(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_UnsetFlag(void * jarg1, int jarg2) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  (arg1)->UnsetFlag(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMol_ClassDescription() { char * jresult ; char *result = 0 ;
  result = (char *)OpenBabel::OBMol::ClassDescription(); jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_RenumberAtoms__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBAtom * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< OpenBabel::OBAtom * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > & type is null", 0);
    return ; }   (arg1)->RenumberAtoms(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_RenumberAtoms__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< int > arg2 ; std::vector< int > *argp2 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  argp2 = (std::vector< int > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< int >", 0);
    return ; }  arg2 = *argp2;  (arg1)->RenumberAtoms(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetCoordinates(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->SetCoordinates(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_ToInertialFrame__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; double *arg3 = (double *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (double *)jarg3;  (arg1)->ToInertialFrame(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_ToInertialFrame__SWIG_1(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->ToInertialFrame(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Translate__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::vector3 *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   (arg1)->Translate((OpenBabel::vector3 const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Translate__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::vector3 *arg2 = 0 ; int arg3 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   arg3 = (int)jarg3;  (arg1)->Translate((OpenBabel::vector3 const &)*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Rotate__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (double *)jarg2; 
  (arg1)->Rotate((double const (*))arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Rotate__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *arg2 ; int arg3 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  (arg1)->Rotate((double const (*))arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Center__SWIG_0(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->Center(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_Kekulize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->Kekulize(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_PerceiveKekuleBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->PerceiveKekuleBonds(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_NewPerceiveKekuleBonds(void * jarg1) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->NewPerceiveKekuleBonds(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteHydrogens__SWIG_0(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->DeleteHydrogens(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteHydrogens__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->DeleteHydrogens(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteNonPolarHydrogens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->DeleteNonPolarHydrogens(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_DeleteHydrogen(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->DeleteHydrogen(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddHydrogens__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, double jarg4) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; bool arg3 ; double arg4 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false;  arg3 = jarg3 ? true : false;  arg4 = (double)jarg4; 
  result = (bool)(arg1)->AddHydrogens(arg2,arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddHydrogens__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; bool arg3 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false;  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->AddHydrogens(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddHydrogens__SWIG_2(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (bool)(arg1)->AddHydrogens(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddHydrogens__SWIG_3(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->AddHydrogens(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddHydrogens__SWIG_4(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->AddHydrogens(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AddPolarHydrogens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->AddPolarHydrogens(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_StripSalts__SWIG_0(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)(arg1)->StripSalts(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_StripSalts__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->StripSalts(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_Separate__SWIG_0(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; std::vector< OpenBabel::OBMol > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->Separate(arg2);
  jresult = new std::vector< OpenBabel::OBMol >((const std::vector< OpenBabel::OBMol > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_Separate__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBMol > result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (arg1)->Separate(); jresult = new std::vector< OpenBabel::OBMol >((const std::vector< OpenBabel::OBMol > &)result); 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_GetNextFragment(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolAtomDFSIter *arg2 = 0 ;
  OpenBabel::OBMol *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBMolAtomDFSIter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolAtomDFSIter & type is null", 0);
    return 0; }   arg3 = (OpenBabel::OBMol *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->GetNextFragment(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_ConvertDativeBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->ConvertDativeBonds(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_CorrectForPH__SWIG_0(void * jarg1, double jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double arg2 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double)jarg2;  result = (bool)(arg1)->CorrectForPH(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_CorrectForPH__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->CorrectForPH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AssignSpinMultiplicity__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(arg1)->AssignSpinMultiplicity(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_AssignSpinMultiplicity__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->AssignSpinMultiplicity(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetIsPatternStructure(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->SetIsPatternStructure(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_Center__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  result = (arg1)->Center(arg2); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetTorsion(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg5 = (OpenBabel::OBAtom *) 0 ; double arg6 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3;  arg4 = (OpenBabel::OBAtom *)jarg4; 
  arg5 = (OpenBabel::OBAtom *)jarg5;  arg6 = (double)jarg6;  (arg1)->SetTorsion(arg2,arg3,arg4,arg5,arg6); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindSSSR(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindSSSR(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindLSSR(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindLSSR(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindRingAtomsAndBonds(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindRingAtomsAndBonds(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindChiralCenters(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindChiralCenters(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindChildren__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< int > *arg2 = 0 ; int arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return ; }
    arg3 = (int)jarg3;  arg4 = (int)jarg4;  (arg1)->FindChildren(*arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindChildren__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBAtom * > *arg2 = 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< OpenBabel::OBAtom * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBAtom *)jarg3;  arg4 = (OpenBabel::OBAtom *)jarg4;  (arg1)->FindChildren(*arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindLargestFragment(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->FindLargestFragment(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_ContigFragList(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< std::vector< int > > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< std::vector< int > > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return ; }   (arg1)->ContigFragList(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Align(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *arg4 = 0 ; OpenBabel::vector3 *arg5 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return ; }
    arg5 = (OpenBabel::vector3 *)jarg5; if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return ; }
    (arg1)->Align(arg2,arg3,*arg4,*arg5); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_ConnectTheDots(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->ConnectTheDots(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_PerceiveBondOrders(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->PerceiveBondOrders(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindAngles(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindAngles(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_FindTorsions(void * jarg1) { OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  (arg1)->FindTorsions(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_GetGTDVector(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< int > *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return 0; }
    result = (bool)(arg1)->GetGTDVector(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_GetGIVector(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< unsigned int > *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return ; }   (arg1)->GetGIVector(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_GetGIDVector(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< unsigned int > *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return ; }   (arg1)->GetGIDVector(*arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_Has2D__SWIG_0(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool arg2 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (bool)(arg1)->Has2D(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_Has2D__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->Has2D(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_Has3D(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->Has3D(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasNonZeroCoords(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasNonZeroCoords(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasAromaticPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasAromaticPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasSSSRPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasSSSRPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasLSSRPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasLSSRPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasRingAtomsAndBondsPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasRingAtomsAndBondsPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasAtomTypesPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasAtomTypesPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasRingTypesPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasRingTypesPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasChiralityPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasChiralityPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasPartialChargesPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasPartialChargesPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasHybridizationPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasHybridizationPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasImplicitValencePerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasImplicitValencePerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasKekulePerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasKekulePerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasClosureBondsPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasClosureBondsPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasChainsPerceived(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasChainsPerceived(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasHydrogensAdded(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasHydrogensAdded(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasAromaticCorrected(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasAromaticCorrected(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_IsCorrectedForPH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->IsCorrectedForPH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_HasSpinMultiplicityAssigned(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->HasSpinMultiplicityAssigned(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMol_Empty(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (bool)(arg1)->Empty(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMol_NumConformers(void * jarg1) { int jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (int)(arg1)->NumConformers(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetConformers(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double * > *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< double * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double * > & type is null", 0);
    return ; }   (arg1)->SetConformers(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_AddConformer(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->AddConformer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetConformer(void * jarg1, int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetConformer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_CopyConformer(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; double *arg2 = (double *) 0 ; int arg3 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  (arg1)->CopyConformer(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_DeleteConformer(void * jarg1, int jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->DeleteConformer(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetConformer(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; double *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  result = (double *)(arg1)->GetConformer(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetEnergies(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double > *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > & type is null", 0);
    return ; }   (arg1)->SetEnergies(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetEnergies(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double > result; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (arg1)->GetEnergies(); jresult = new std::vector< double >((const std::vector< double > &)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMol_GetEnergy__SWIG_1(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; double result; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (int)jarg2;  result = (double)(arg1)->GetEnergy(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ThrowError__SWIG_0(char * jarg1) { char *arg1 = (char *) 0 ; arg1 = (char *)jarg1; 
  OpenBabel::ThrowError(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_ThrowError__SWIG_1(void * jarg1) { std::string *arg1 = 0 ; arg1 = (std::string *)jarg1;
  if (!arg1) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0);
    return ; }   OpenBabel::ThrowError(*arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_CartesianToInternal(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > & type is null", 0);
    return ; }   arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  OpenBabel::CartesianToInternal(*arg1,*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_InternalToCartesian(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBInternalCoord * > *arg1 = 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBInternalCoord * > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * > & type is null", 0);
    return ; }   arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  OpenBabel::InternalToCartesian(*arg1,*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_NewExtension(void * jarg1, char * jarg2) { char * jresult ; std::string *arg1 = 0 ;
  char *arg2 = (char *) 0 ; std::string result; arg1 = (std::string *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg2 = (char *)jarg2;  result = OpenBabel::NewExtension(*arg1,arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_etab_set(void * jarg1) { OpenBabel::OBElementTable *arg1 = (OpenBabel::OBElementTable *) 0 ;
  arg1 = (OpenBabel::OBElementTable *)jarg1;  OpenBabel::etab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_etab_get() { void * jresult ; OpenBabel::OBElementTable *result = 0 ;
  result = (OpenBabel::OBElementTable *)&OpenBabel::etab; jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ttab_set(void * jarg1) { OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ;
  arg1 = (OpenBabel::OBTypeTable *)jarg1;  OpenBabel::ttab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_ttab_get() { void * jresult ; OpenBabel::OBTypeTable *result = 0 ;
  result = (OpenBabel::OBTypeTable *)&OpenBabel::ttab; jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_isotab_set(void * jarg1) {
  OpenBabel::OBIsotopeTable *arg1 = (OpenBabel::OBIsotopeTable *) 0 ; arg1 = (OpenBabel::OBIsotopeTable *)jarg1; 
  OpenBabel::isotab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_isotab_get() { void * jresult ; OpenBabel::OBIsotopeTable *result = 0 ;
  result = (OpenBabel::OBIsotopeTable *)&OpenBabel::isotab; jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_atomtyper_set(void * jarg1) { OpenBabel::OBAtomTyper *arg1 = (OpenBabel::OBAtomTyper *) 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1;  OpenBabel::atomtyper = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_atomtyper_get() { void * jresult ; OpenBabel::OBAtomTyper *result = 0 ;
  result = (OpenBabel::OBAtomTyper *)&OpenBabel::atomtyper; jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_chainsparser_set(void * jarg1) {
  OpenBabel::OBChainsParser *arg1 = (OpenBabel::OBChainsParser *) 0 ; arg1 = (OpenBabel::OBChainsParser *)jarg1; 
  OpenBabel::chainsparser = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_chainsparser_get() { void * jresult ; OpenBabel::OBChainsParser *result = 0 ;
  result = (OpenBabel::OBChainsParser *)&OpenBabel::chainsparser; jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_resdat_set(void * jarg1) { OpenBabel::OBResidueData *arg1 = (OpenBabel::OBResidueData *) 0 ;
  arg1 = (OpenBabel::OBResidueData *)jarg1;  OpenBabel::resdat = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_resdat_get() { void * jresult ; OpenBabel::OBResidueData *result = 0 ;
  result = (OpenBabel::OBResidueData *)&OpenBabel::resdat; jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NoId_get() { unsigned long jresult ; unsigned long result;
  result = (unsigned long)(unsigned long)OpenBabel::NoId; jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_get_rmat(void * jarg1, void * jarg2, void * jarg3, int jarg4) { double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; int arg4 ; arg1 = (double *)jarg1;  arg2 = (double *)jarg2; 
  arg3 = (double *)jarg3;  arg4 = (int)jarg4;  OpenBabel::get_rmat(arg1,arg2,arg3,arg4); }
SWIGEXPORT double SWIGSTDCALL CSharp_superimpose(void * jarg1, void * jarg2, int jarg3) { double jresult ;
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; int arg3 ; double result; arg1 = (double *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  result = (double)OpenBabel::superimpose(arg1,arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRing_ring_id_set(void * jarg1, int jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (int)jarg2; 
  if (arg1) (arg1)->ring_id = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRing_ring_id_get(void * jarg1) { int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; int result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (int) ((arg1)->ring_id); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRing__path_set(void * jarg1, void * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; std::vector< int > *arg2 = (std::vector< int > *) 0 ;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (std::vector< int > *)jarg2;  if (arg1) (arg1)->_path = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRing__path_get(void * jarg1) { void * jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; std::vector< int > *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (std::vector< int > *)& ((arg1)->_path); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRing__pathset_set(void * jarg1, void * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBBitVec *arg2 = (OpenBabel::OBBitVec *) 0 ;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2;  if (arg1) (arg1)->_pathset = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRing__pathset_get(void * jarg1) { void * jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBBitVec *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (OpenBabel::OBBitVec *)& ((arg1)->_pathset); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRing__SWIG_0() { void * jresult ; OpenBabel::OBRing *result = 0 ;
  result = (OpenBabel::OBRing *)new OpenBabel::OBRing(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRing__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  std::vector< int > *arg1 = 0 ; int arg2 ; OpenBabel::OBRing *result = 0 ; arg1 = (std::vector< int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return 0; }
    arg2 = (int)jarg2;  result = (OpenBabel::OBRing *)new OpenBabel::OBRing(*arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRing__SWIG_2(void * jarg1, void * jarg2) { void * jresult ;
  std::vector< int > *arg1 = 0 ; OpenBabel::OBBitVec arg2 ; OpenBabel::OBBitVec *argp2 ; OpenBabel::OBRing *result = 0 ;
  arg1 = (std::vector< int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return 0; }
    argp2 = (OpenBabel::OBBitVec *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null OpenBabel::OBBitVec", 0);
    return 0; }  arg2 = *argp2;  result = (OpenBabel::OBRing *)new OpenBabel::OBRing(*arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRing__SWIG_3(void * jarg1) { void * jresult ; OpenBabel::OBRing *arg1 = 0 ;
  OpenBabel::OBRing *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRing const & type is null", 0);
    return 0; }   result = (OpenBabel::OBRing *)new OpenBabel::OBRing((OpenBabel::OBRing const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBRing_Size(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; size_t result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = ((OpenBabel::OBRing const *)arg1)->Size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBRing_PathSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; size_t result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = ((OpenBabel::OBRing const *)arg1)->PathSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; bool result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (bool)(arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRing_SetType(void * jarg1, char * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetType(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBRing_GetRingType(void * jarg1) { char * jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (char *)(arg1)->GetType(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_GetRootAtom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; unsigned int result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (unsigned int)(arg1)->GetRootAtom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_IsMember__SWIG_0(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; bool result;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  result = (bool)(arg1)->IsMember(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_IsMember__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; bool result;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  result = (bool)(arg1)->IsMember(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_IsInRing(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)(arg1)->IsInRing(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRing_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (arg1)->SetParent(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRing_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBMol *result = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (OpenBabel::OBMol *)(arg1)->GetParent(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRing_findCenterAndNormal(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 *arg4 = 0 ; bool result; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (bool)(arg1)->findCenterAndNormal(*arg2,*arg3,*arg4); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRing(void * jarg1) { OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ;
  arg1 = (OpenBabel::OBRing *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CompareRingSize(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; OpenBabel::OBRing *arg2 = (OpenBabel::OBRing *) 0 ; bool result;
  arg1 = (OpenBabel::OBRing *)jarg1;  arg2 = (OpenBabel::OBRing *)jarg2; 
  result = (bool)OpenBabel::CompareRingSize((OpenBabel::OBRing const *)arg1,(OpenBabel::OBRing const *)arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRTree(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBRTree *arg2 = (OpenBabel::OBRTree *) 0 ;
  OpenBabel::OBRTree *result = 0 ; arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBRTree *)jarg2; 
  result = (OpenBabel::OBRTree *)new OpenBabel::OBRTree(arg1,arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRTree(void * jarg1) { OpenBabel::OBRTree *arg1 = (OpenBabel::OBRTree *) 0 ;
  arg1 = (OpenBabel::OBRTree *)jarg1;  delete arg1; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRTree_GetAtomIdx(void * jarg1) { int jresult ;
  OpenBabel::OBRTree *arg1 = (OpenBabel::OBRTree *) 0 ; int result; arg1 = (OpenBabel::OBRTree *)jarg1; 
  result = (int)(arg1)->GetAtomIdx(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRTree_PathToRoot(void * jarg1, void * jarg2) {
  OpenBabel::OBRTree *arg1 = (OpenBabel::OBRTree *) 0 ; std::vector< OpenBabel::OBAtom * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBRTree *)jarg1;  arg2 = (std::vector< OpenBabel::OBAtom * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * > & type is null", 0);
    return ; }   (arg1)->PathToRoot(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSmartsPattern__SWIG_0() { void * jresult ; OpenBabel::OBSmartsPattern *result = 0 ;
  result = (OpenBabel::OBSmartsPattern *)new OpenBabel::OBSmartsPattern(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSmartsPattern(void * jarg1) {
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSmartsPattern__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = 0 ; OpenBabel::OBSmartsPattern *result = 0 ; arg1 = (OpenBabel::OBSmartsPattern *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBSmartsPattern const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBSmartsPattern *)new OpenBabel::OBSmartsPattern((OpenBabel::OBSmartsPattern const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Init__SWIG_0(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(arg1)->Init((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBSmartsPattern_GetSMARTS__SWIG_0(void * jarg1) { char * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  result = (std::string *) &((OpenBabel::OBSmartsPattern const *)arg1)->GetSMARTS();
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Empty(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (bool)((OpenBabel::OBSmartsPattern const *)arg1)->Empty();
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_IsValid(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (bool)((OpenBabel::OBSmartsPattern const *)arg1)->IsValid();
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_NumAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (unsigned int)((OpenBabel::OBSmartsPattern const *)arg1)->NumAtoms();
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_NumBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (unsigned int)((OpenBabel::OBSmartsPattern const *)arg1)->NumBonds();
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSmartsPattern_GetBond(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; int *arg2 = 0 ; int *arg3 = 0 ; int *arg4 = 0 ;
  int arg5 ; arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (int *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  arg3 = (int *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  arg4 = (int *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); return ; }  
  arg5 = (int)jarg5;  (arg1)->GetBond(*arg2,*arg3,*arg4,arg5); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBSmartsPattern_GetAtomicNum(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (int)jarg2;  result = (int)(arg1)->GetAtomicNum(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBSmartsPattern_GetCharge(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (int)jarg2;  result = (int)(arg1)->GetCharge(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBSmartsPattern_GetVectorBinding(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBSmartsPattern const *)arg1)->GetVectorBinding(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Match__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  bool arg3 ; bool result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = jarg3 ? true : false;  result = (bool)(arg1)->Match(*arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Match__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->Match(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Match__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  unsigned int jresult ; OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  std::vector< std::vector< int > > *arg3 = 0 ; OpenBabel::OBSmartsPattern::MatchType arg4 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (std::vector< std::vector< int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return 0; }   arg4 = (OpenBabel::OBSmartsPattern::MatchType)jarg4; 
  result = (bool)((OpenBabel::OBSmartsPattern const *)arg1)->Match(*arg2,*arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_Match__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  std::vector< std::vector< int > > *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (std::vector< std::vector< int > > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return 0; }   result = (bool)((OpenBabel::OBSmartsPattern const *)arg1)->Match(*arg2,*arg3); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_HasMatch(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)((OpenBabel::OBSmartsPattern const *)arg1)->HasMatch(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_RestrictedMatch__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ; OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBBitVec *arg3 = 0 ; bool arg4 ; bool result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (OpenBabel::OBBitVec *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0);
    return 0; }   arg4 = jarg4 ? true : false;  result = (bool)(arg1)->RestrictedMatch(*arg2,*arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_RestrictedMatch__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBBitVec *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;
  if (!arg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0);
    return 0; }   arg3 = (OpenBabel::OBBitVec *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0);
    return 0; }   result = (bool)(arg1)->RestrictedMatch(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_NumMatches(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (unsigned int)((OpenBabel::OBSmartsPattern const *)arg1)->NumMatches();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSmartsPattern_GetMapList(void * jarg1) { void * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; std::vector< std::vector< int > > *result = 0 ;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (std::vector< std::vector< int > > *) &(arg1)->GetMapList();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSmartsPattern_GetUMapList(void * jarg1) { void * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; std::vector< std::vector< int > > *result = 0 ;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  result = (std::vector< std::vector< int > > *) &(arg1)->GetUMapList();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSmartsPattern_WriteMapList(void * jarg1, void * jarg2) {
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ; std::ostream *arg2 = 0 ;
  arg1 = (OpenBabel::OBSmartsPattern *)jarg1;  arg2 = (std::ostream *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0); return ; }  
  (arg1)->WriteMapList(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBSmartsMatcher() { void * jresult ; OpenBabel::OBSmartsMatcher *result = 0 ;
  result = (OpenBabel::OBSmartsMatcher *)new OpenBabel::OBSmartsMatcher(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSmartsMatcher(void * jarg1) {
  OpenBabel::OBSmartsMatcher *arg1 = (OpenBabel::OBSmartsMatcher *) 0 ; arg1 = (OpenBabel::OBSmartsMatcher *)jarg1; 
  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsMatcher_match__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  unsigned int jresult ; OpenBabel::OBSmartsMatcher *arg1 = (OpenBabel::OBSmartsMatcher *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::Pattern *arg3 = (OpenBabel::Pattern *) 0 ; std::vector< std::vector< int > > *arg4 = 0 ; bool arg5 ; bool result;
  arg1 = (OpenBabel::OBSmartsMatcher *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (OpenBabel::Pattern *)jarg3;  arg4 = (std::vector< std::vector< int > > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return 0; }   arg5 = jarg5 ? true : false;  result = (bool)(arg1)->match(*arg2,(OpenBabel::Pattern const *)arg3,*arg4,arg5);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsMatcher_match__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBSmartsMatcher *arg1 = (OpenBabel::OBSmartsMatcher *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::Pattern *arg3 = (OpenBabel::Pattern *) 0 ; std::vector< std::vector< int > > *arg4 = 0 ; bool result;
  arg1 = (OpenBabel::OBSmartsMatcher *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (OpenBabel::Pattern *)jarg3;  arg4 = (std::vector< std::vector< int > > *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return 0; }   result = (bool)(arg1)->match(*arg2,(OpenBabel::Pattern const *)arg3,*arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_AliasDataType_get() { unsigned int jresult ; unsigned int result;
  result = (unsigned int)(unsigned int)OpenBabel::AliasDataType; jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_AliasData() { void * jresult ; OpenBabel::AliasData *result = 0 ;
  result = (OpenBabel::AliasData *)new OpenBabel::AliasData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_AliasData_SetAlias__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::AliasData *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetAlias((std::string const &)*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_AliasData_GetAlias__SWIG_0(void * jarg1, unsigned int jarg2) { char * jresult ;
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; bool arg2 ; std::string result;
  arg1 = (OpenBabel::AliasData *)jarg1;  arg2 = jarg2 ? true : false; 
  result = ((OpenBabel::AliasData const *)arg1)->GetAlias(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_AliasData_GetAlias__SWIG_1(void * jarg1) { char * jresult ;
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::string result; arg1 = (OpenBabel::AliasData *)jarg1; 
  result = ((OpenBabel::AliasData const *)arg1)->GetAlias(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_AliasData_GetColor(void * jarg1) { char * jresult ;
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::string result; arg1 = (OpenBabel::AliasData *)jarg1; 
  result = ((OpenBabel::AliasData const *)arg1)->GetColor(); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_AliasData_SetColor(void * jarg1, char * jarg2) {
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::string arg2 ; arg1 = (OpenBabel::AliasData *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->SetColor(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_AliasData_IsExpanded(void * jarg1) { unsigned int jresult ;
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; bool result; arg1 = (OpenBabel::AliasData *)jarg1; 
  result = (bool)((OpenBabel::AliasData const *)arg1)->IsExpanded(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_AliasData_RevertToAliasForm(void * jarg1) { OpenBabel::OBMol *arg1 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  OpenBabel::AliasData::RevertToAliasForm(*arg1); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_AliasData_Expand(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  unsigned int arg3 ; bool result; arg1 = (OpenBabel::AliasData *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (unsigned int)jarg3;  result = (bool)(arg1)->Expand(*arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_AliasData(void * jarg1) { OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ;
  arg1 = (OpenBabel::AliasData *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomClassData() { void * jresult ; OpenBabel::OBAtomClassData *result = 0 ;
  result = (OpenBabel::OBAtomClassData *)new OpenBabel::OBAtomClassData(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomClassData_Clear(void * jarg1) {
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; arg1 = (OpenBabel::OBAtomClassData *)jarg1; 
  (arg1)->Clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomClassData_Add(void * jarg1, int jarg2, int jarg3) {
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; int arg2 ; int arg3 ;
  arg1 = (OpenBabel::OBAtomClassData *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  (arg1)->Add(arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomClassData_HasClass(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomClassData *)jarg1;  arg2 = (int)jarg2; 
  result = (bool)((OpenBabel::OBAtomClassData const *)arg1)->HasClass(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtomClassData_GetClass(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBAtomClassData *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBAtomClassData const *)arg1)->GetClass(arg2); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBAtomClassData_GetClassString(void * jarg1, int jarg2) { char * jresult ;
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; int arg2 ; std::string result;
  arg1 = (OpenBabel::OBAtomClassData *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->GetClassString(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtomClassData_size(void * jarg1) { int jresult ;
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; int result; arg1 = (OpenBabel::OBAtomClassData *)jarg1; 
  result = (int)(arg1)->size(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAtomClassData(void * jarg1) {
  OpenBabel::OBAtomClassData *arg1 = (OpenBabel::OBAtomClassData *) 0 ; arg1 = (OpenBabel::OBAtomClassData *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFingerprint_Default() { void * jresult ; OpenBabel::OBFingerprint **result = 0 ;
  result = (OpenBabel::OBFingerprint **) &OpenBabel::OBFingerprint::Default(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFingerprint_FindType(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFingerprint *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFingerprint *)OpenBabel::OBFingerprint::FindType((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFingerprint(void * jarg1) {
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; arg1 = (OpenBabel::OBFingerprint *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFingerprint_SetBit(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; std::vector< unsigned int > *arg2 = 0 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return ; }   arg3 = (unsigned int)jarg3;  (arg1)->SetBit(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFingerprint_GetBit(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ; unsigned int arg3 ; bool result; arg1 = (OpenBabel::OBFingerprint *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }   arg3 = (unsigned int)jarg3;  result = (bool)(arg1)->GetBit((std::vector< unsigned int > const &)*arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFingerprint_Fold(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; std::vector< unsigned int > *arg2 = 0 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return ; }   arg3 = (unsigned int)jarg3;  (arg1)->Fold(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFingerprint_GetFingerprint__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  unsigned int jresult ; OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::vector< unsigned int > *arg3 = 0 ; int arg4 ; bool result;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return 0; }   arg4 = (int)jarg4;  result = (bool)(arg1)->GetFingerprint(arg2,*arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFingerprint_GetFingerprint__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::vector< unsigned int > *arg3 = 0 ; bool result;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return 0; }   result = (bool)(arg1)->GetFingerprint(arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFingerprint_Flags(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  result = (unsigned int)(arg1)->Flags(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFingerprint_SetFlags(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  arg2 = (unsigned int)jarg2;  (arg1)->SetFlags(arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFingerprint_DescribeBits__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  char * jresult ; OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; std::vector< unsigned int > arg2 ;
  bool arg3 ; std::vector< unsigned int > const *argp2 ; std::string result; arg1 = (OpenBabel::OBFingerprint *)jarg1; 
  argp2 = (std::vector< unsigned int > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< unsigned int > const", 0);
    return 0; }  arg2 = *argp2;  arg3 = jarg3 ? true : false;  result = (arg1)->DescribeBits(arg2,arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFingerprint_DescribeBits__SWIG_1(void * jarg1, void * jarg2) { char * jresult ;
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; std::vector< unsigned int > arg2 ;
  std::vector< unsigned int > const *argp2 ; std::string result; arg1 = (OpenBabel::OBFingerprint *)jarg1; 
  argp2 = (std::vector< unsigned int > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< unsigned int > const", 0);
    return 0; }  arg2 = *argp2;  result = (arg1)->DescribeBits(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFingerprint_Tanimoto__SWIG_0(void * jarg1, void * jarg2) { double jresult ;
  std::vector< unsigned int > *arg1 = 0 ; std::vector< unsigned int > *arg2 = 0 ; double result;
  arg1 = (std::vector< unsigned int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }   arg2 = (std::vector< unsigned int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }  
  result = (double)OpenBabel::OBFingerprint::Tanimoto((std::vector< unsigned int > const &)*arg1,(std::vector< unsigned int > const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFingerprint_Tanimoto__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  std::vector< unsigned int > *arg1 = 0 ; unsigned int *arg2 = (unsigned int *) 0 ; double result;
  arg1 = (std::vector< unsigned int > *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return 0; }   arg2 = (unsigned int *)jarg2; 
  result = (double)OpenBabel::OBFingerprint::Tanimoto((std::vector< unsigned int > const &)*arg1,(unsigned int const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFingerprint_Getbitsperint() { unsigned int jresult ; unsigned int result;
  result = (unsigned int)OpenBabel::OBFingerprint::Getbitsperint(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFingerprint_FindFingerprint(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBFingerprint *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBFingerprint *)OpenBabel::OBFingerprint::FindFingerprint((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndexHeader_headerlength_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  arg2 = (unsigned int)jarg2;  if (arg1) (arg1)->headerlength = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FptIndexHeader_headerlength_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int result;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  result = (unsigned int) ((arg1)->headerlength); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndexHeader_nEntries_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  arg2 = (unsigned int)jarg2;  if (arg1) (arg1)->nEntries = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FptIndexHeader_nEntries_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int result;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  result = (unsigned int) ((arg1)->nEntries); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndexHeader_words_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  arg2 = (unsigned int)jarg2;  if (arg1) (arg1)->words = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FptIndexHeader_words_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; unsigned int result;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  result = (unsigned int) ((arg1)->words); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndexHeader_fpid_set(void * jarg1, char * jarg2) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; char *arg2 ; arg1 = (OpenBabel::FptIndexHeader *)jarg1; 
  arg2 = (char *)jarg2;  { if(arg2) { strncpy((char*)arg1->fpid, (const char *)arg2, 16-1); arg1->fpid[16-1] = 0; }  else {
      arg1->fpid[0] = 0; }  }  }
SWIGEXPORT char * SWIGSTDCALL CSharp_FptIndexHeader_fpid_get(void * jarg1) { char * jresult ;
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  result = (char *)(char *) ((arg1)->fpid);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndexHeader_datafilename_set(void * jarg1, char * jarg2) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; char *arg2 ; arg1 = (OpenBabel::FptIndexHeader *)jarg1; 
  arg2 = (char *)jarg2;  { if(arg2) { strncpy((char*)arg1->datafilename, (const char *)arg2, 256-1);
      arg1->datafilename[256-1] = 0; }  else { arg1->datafilename[0] = 0; }  }  }
SWIGEXPORT char * SWIGSTDCALL CSharp_FptIndexHeader_datafilename_get(void * jarg1) { char * jresult ;
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::FptIndexHeader *)jarg1;  result = (char *)(char *) ((arg1)->datafilename);
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FptIndexHeader() { void * jresult ; OpenBabel::FptIndexHeader *result = 0 ;
  result = (OpenBabel::FptIndexHeader *)new OpenBabel::FptIndexHeader(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_FptIndexHeader(void * jarg1) {
  OpenBabel::FptIndexHeader *arg1 = (OpenBabel::FptIndexHeader *) 0 ; arg1 = (OpenBabel::FptIndexHeader *)jarg1;  delete arg1; }
SWIGEXPORT char * SWIGSTDCALL CSharp_FastSearch_ReadIndexFile(void * jarg1, char * jarg2) { char * jresult ;
  OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ; std::string arg2 ; std::string result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg2)->assign(jarg2);  result = (arg1)->ReadIndexFile(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_FastSearch_ReadIndex(void * jarg1, void * jarg2) { char * jresult ;
  OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ; std::istream *arg2 = (std::istream *) 0 ; std::string result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (std::istream *)jarg2;  result = (arg1)->ReadIndex(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_FastSearch(void * jarg1) { OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  arg1 = (OpenBabel::FastSearch *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_Find(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::vector< unsigned int > *arg3 = 0 ; unsigned int arg4 ; bool result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return 0; }   arg4 = (unsigned int)jarg4;  result = (bool)(arg1)->Find(arg2,*arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_FindMatch(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::vector< unsigned int > *arg3 = 0 ; unsigned int arg4 ; bool result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return 0; }   arg4 = (unsigned int)jarg4;  result = (bool)(arg1)->FindMatch(arg2,*arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_FindSimilar__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::multimap< double,unsigned int > *arg3 = 0 ; double arg4 ;
  double arg5 ; bool result; arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (std::multimap< double,unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::multimap< double,unsigned int > & type is null", 0);
    return 0; }   arg4 = (double)jarg4;  arg5 = (double)jarg5;  result = (bool)(arg1)->FindSimilar(arg2,*arg3,arg4,arg5);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_FindSimilar__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::multimap< double,unsigned int > *arg3 = 0 ; double arg4 ;
  bool result; arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (std::multimap< double,unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::multimap< double,unsigned int > & type is null", 0);
    return 0; }   arg4 = (double)jarg4;  result = (bool)(arg1)->FindSimilar(arg2,*arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_FindSimilar__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::multimap< double,unsigned int > *arg3 = 0 ; int arg4 ; bool result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (std::multimap< double,unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::multimap< double,unsigned int > & type is null", 0);
    return 0; }   arg4 = (int)jarg4;  result = (bool)(arg1)->FindSimilar(arg2,*arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FastSearch_FindSimilar__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::multimap< double,unsigned int > *arg3 = 0 ; bool result;
  arg1 = (OpenBabel::FastSearch *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  arg3 = (std::multimap< double,unsigned int > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::multimap< double,unsigned int > & type is null", 0);
    return 0; }   result = (bool)(arg1)->FindSimilar(arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FastSearch_GetFingerprint(void * jarg1) { void * jresult ;
  OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ; OpenBabel::OBFingerprint *result = 0 ;
  arg1 = (OpenBabel::FastSearch *)jarg1; 
  result = (OpenBabel::OBFingerprint *)((OpenBabel::FastSearch const *)arg1)->GetFingerprint(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FastSearch_GetIndexHeader(void * jarg1) { void * jresult ;
  OpenBabel::FastSearch *arg1 = (OpenBabel::FastSearch *) 0 ; OpenBabel::FptIndexHeader *result = 0 ;
  arg1 = (OpenBabel::FastSearch *)jarg1; 
  result = (OpenBabel::FptIndexHeader *) &((OpenBabel::FastSearch const *)arg1)->GetIndexHeader(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearch() { void * jresult ; OpenBabel::FastSearch *result = 0 ;
  result = (OpenBabel::FastSearch *)new OpenBabel::FastSearch(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearchIndexer__SWIG_0(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ; std::string *arg1 = 0 ; std::ostream *arg2 = (std::ostream *) 0 ; std::string *arg3 = 0 ; int arg4 ;
  int arg5 ; OpenBabel::FastSearchIndexer *result = 0 ; arg1 = (std::string *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg2 = (std::ostream *)jarg2;  arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg4 = (int)jarg4;  arg5 = (int)jarg5; 
  result = (OpenBabel::FastSearchIndexer *)new OpenBabel::FastSearchIndexer(*arg1,arg2,*arg3,arg4,arg5);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearchIndexer__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ; std::string *arg1 = 0 ; std::ostream *arg2 = (std::ostream *) 0 ; std::string *arg3 = 0 ; int arg4 ;
  OpenBabel::FastSearchIndexer *result = 0 ; arg1 = (std::string *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg2 = (std::ostream *)jarg2;  arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg4 = (int)jarg4;  result = (OpenBabel::FastSearchIndexer *)new OpenBabel::FastSearchIndexer(*arg1,arg2,*arg3,arg4);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearchIndexer__SWIG_2(void * jarg1, void * jarg2, void * jarg3) { void * jresult ;
  std::string *arg1 = 0 ; std::ostream *arg2 = (std::ostream *) 0 ; std::string *arg3 = 0 ;
  OpenBabel::FastSearchIndexer *result = 0 ; arg1 = (std::string *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg2 = (std::ostream *)jarg2;  arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  result = (OpenBabel::FastSearchIndexer *)new OpenBabel::FastSearchIndexer(*arg1,arg2,*arg3); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearchIndexer__SWIG_3(void * jarg1, void * jarg2, int jarg3) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ; int arg3 ;
  OpenBabel::FastSearchIndexer *result = 0 ; arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (std::ostream *)jarg2; 
  arg3 = (int)jarg3;  result = (OpenBabel::FastSearchIndexer *)new OpenBabel::FastSearchIndexer(arg1,arg2,arg3);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FastSearchIndexer__SWIG_4(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ;
  OpenBabel::FastSearchIndexer *result = 0 ; arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (std::ostream *)jarg2; 
  result = (OpenBabel::FastSearchIndexer *)new OpenBabel::FastSearchIndexer(arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_FastSearchIndexer(void * jarg1) {
  OpenBabel::FastSearchIndexer *arg1 = (OpenBabel::FastSearchIndexer *) 0 ; arg1 = (OpenBabel::FastSearchIndexer *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDescriptor_Default() { void * jresult ; OpenBabel::OBDescriptor **result = 0 ;
  result = (OpenBabel::OBDescriptor **) &OpenBabel::OBDescriptor::Default(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBDescriptor__SWIG_0(char * jarg1, unsigned int jarg2) { void * jresult ;
  char *arg1 = (char *) 0 ; bool arg2 ; OpenBabel::OBDescriptor *result = 0 ; arg1 = (char *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (OpenBabel::OBDescriptor *)new OpenBabel::OBDescriptor((char const *)arg1,arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBDescriptor__SWIG_1(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBDescriptor *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBDescriptor *)new OpenBabel::OBDescriptor((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDescriptor_FindType(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBDescriptor *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBDescriptor *)OpenBabel::OBDescriptor::FindType((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_Predict__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { double jresult ;
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  std::string *arg3 = (std::string *) 0 ; double result; arg1 = (OpenBabel::OBDescriptor *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::string *)jarg3;  result = (double)(arg1)->Predict(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_Predict__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  double result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (double)(arg1)->Predict(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_PredictAndSave__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string *arg3 = (std::string *) 0 ; double result;
  arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::string *)jarg3; 
  result = (double)(arg1)->PredictAndSave(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_PredictAndSave__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  double result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (double)(arg1)->PredictAndSave(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_GetStringValue__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string *arg3 = 0 ; std::string *arg4 = (std::string *) 0 ;
  double result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::string *)jarg3;
  if (!arg3) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0);
    return 0; }   arg4 = (std::string *)jarg4;  result = (double)(arg1)->GetStringValue(arg2,*arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_GetStringValue__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::string *arg3 = 0 ; double result;
  arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::string *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  result = (double)(arg1)->GetStringValue(arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Compare__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::istream *arg3 = 0 ; bool arg4 ;
  std::string *arg5 = (std::string *) 0 ; bool result; arg1 = (OpenBabel::OBDescriptor *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::istream *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::istream & type is null", 0); return 0; }  
  arg4 = jarg4 ? true : false;  arg5 = (std::string *)jarg5;  result = (bool)(arg1)->Compare(arg2,*arg3,arg4,arg5);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Compare__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::istream *arg3 = 0 ; bool arg4 ; bool result;
  arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (std::istream *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::istream & type is null", 0); return 0; }  
  arg4 = jarg4 ? true : false;  result = (bool)(arg1)->Compare(arg2,*arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Display__SWIG_0(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; char *arg4 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBDescriptor *)jarg1; 
  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  arg4 = (char *)jarg4;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3,(char const *)arg4);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Display__SWIG_1(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ; bool result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  arg3 = (char *)jarg3;  result = (bool)(arg1)->Display(*arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Order__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; double arg2 ; double arg3 ;
  bool result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3; 
  result = (bool)(arg1)->Order(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_Order__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; std::string arg2 ; std::string arg3 ;
  bool result; arg1 = (OpenBabel::OBDescriptor *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg2)->assign(jarg2);  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  (&arg3)->assign(jarg3);  result = (bool)(arg1)->Order(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBDescriptor_FilterCompare(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ; OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::istream *arg2 = 0 ; bool arg3 ; bool result;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (std::istream *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::istream & type is null", 0); return 0; }  
  arg3 = jarg3 ? true : false;  result = (bool)OpenBabel::OBDescriptor::FilterCompare(arg1,*arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBDescriptor_AddProperties(void * jarg1, char * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBBase *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  OpenBabel::OBDescriptor::AddProperties(arg1,(std::string const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBDescriptor_DeleteProperties(void * jarg1, char * jarg2) {
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBBase *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  OpenBabel::OBDescriptor::DeleteProperties(arg1,(std::string const &)*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBDescriptor_GetValues(void * jarg1, char * jarg2) { char * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string *arg2 = 0 ; std::string result;
  arg1 = (OpenBabel::OBBase *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  result = OpenBabel::OBDescriptor::GetValues(arg1,(std::string const &)*arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDescriptor_GetIdentifier(void * jarg1) { void * jresult ; std::istream *arg1 = 0 ;
  SwigValueWrapper< std::pair< std::string,std::string > > result; arg1 = (std::istream *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::istream & type is null", 0); return 0; }  
  result = OpenBabel::OBDescriptor::GetIdentifier(*arg1);
  jresult = new std::pair< std::string,std::string >((const std::pair< std::string,std::string > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBDescriptor(void * jarg1) {
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; arg1 = (OpenBabel::OBDescriptor *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_LineSearchType() { void * jresult ; OpenBabel::LineSearchType *result = 0 ;
  result = (OpenBabel::LineSearchType *)new OpenBabel::LineSearchType(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_LineSearchType(void * jarg1) {
  OpenBabel::LineSearchType *arg1 = (OpenBabel::LineSearchType *) 0 ; arg1 = (OpenBabel::LineSearchType *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter_a_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->a = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFParameter_a_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int result; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  result = (int) ((arg1)->a); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter_b_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->b = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFParameter_b_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int result; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  result = (int) ((arg1)->b); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter_c_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->c = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFParameter_c_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int result; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  result = (int) ((arg1)->c); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter_d_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->d = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFParameter_d_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; int result; arg1 = (OpenBabel::OBFFParameter *)jarg1; 
  result = (int) ((arg1)->d); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__a_set(void * jarg1, char * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (arg1) (arg1)->_a = *arg2; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFFParameter__a_get(void * jarg1) { char * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::string *) & ((arg1)->_a);
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__b_set(void * jarg1, char * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (arg1) (arg1)->_b = *arg2; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFFParameter__b_get(void * jarg1) { char * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::string *) & ((arg1)->_b);
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__c_set(void * jarg1, char * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (arg1) (arg1)->_c = *arg2; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFFParameter__c_get(void * jarg1) { char * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::string *) & ((arg1)->_c);
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__d_set(void * jarg1, char * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  if (arg1) (arg1)->_d = *arg2; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBFFParameter__d_get(void * jarg1) { char * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::string *) & ((arg1)->_d);
  jresult = SWIG_csharp_string_callback(result->c_str());  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__ipar_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::vector< int > *arg2 = (std::vector< int > *) 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  arg2 = (std::vector< int > *)jarg2;  if (arg1) (arg1)->_ipar = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFParameter__ipar_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::vector< int > *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::vector< int > *)& ((arg1)->_ipar); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter__dpar_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  arg2 = (std::vector< double > *)jarg2;  if (arg1) (arg1)->_dpar = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFParameter__dpar_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; std::vector< double > *result = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  result = (std::vector< double > *)& ((arg1)->_dpar); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFParameter_clear(void * jarg1) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; arg1 = (OpenBabel::OBFFParameter *)jarg1;  (arg1)->clear(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFParameter() { void * jresult ; OpenBabel::OBFFParameter *result = 0 ;
  result = (OpenBabel::OBFFParameter *)new OpenBabel::OBFFParameter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFParameter(void * jarg1) {
  OpenBabel::OBFFParameter *arg1 = (OpenBabel::OBFFParameter *) 0 ; arg1 = (OpenBabel::OBFFParameter *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_energy_set(void * jarg1, double jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (double)jarg2;  if (arg1) (arg1)->energy = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFCalculation2_energy_get(void * jarg1) { double jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double result;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (double) ((arg1)->energy); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_a_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->a = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_a_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->a); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_b_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->b = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_b_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->b); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_idx_a_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (int)jarg2;  if (arg1) (arg1)->idx_a = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFCalculation2_idx_a_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; int result;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (int) ((arg1)->idx_a); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_idx_b_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (int)jarg2;  if (arg1) (arg1)->idx_b = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFCalculation2_idx_b_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; int result;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (int) ((arg1)->idx_b); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_pos_a_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *arg2 = (double *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (double *)jarg2;  if (arg1) (arg1)->pos_a = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_pos_a_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (double *) ((arg1)->pos_a); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_pos_b_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *arg2 = (double *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (double *)jarg2;  if (arg1) (arg1)->pos_b = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_pos_b_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (double *) ((arg1)->pos_b); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_force_a_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *arg2 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (double *)jarg2;  { size_t ii; double *b = (double *) arg1->force_a;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((double *) arg2 + ii); }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_force_a_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (double *)(double *) ((arg1)->force_a); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_force_b_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *arg2 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  arg2 = (double *)jarg2;  { size_t ii; double *b = (double *) arg1->force_b;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((double *) arg2 + ii); }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation2_force_b_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation2 *)jarg1;  result = (double *)(double *) ((arg1)->force_b); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFCalculation2(void * jarg1) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; arg1 = (OpenBabel::OBFFCalculation2 *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation2_SetupPointers(void * jarg1) {
  OpenBabel::OBFFCalculation2 *arg1 = (OpenBabel::OBFFCalculation2 *) 0 ; arg1 = (OpenBabel::OBFFCalculation2 *)jarg1; 
  (arg1)->SetupPointers(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFCalculation2() { void * jresult ; OpenBabel::OBFFCalculation2 *result = 0 ;
  result = (OpenBabel::OBFFCalculation2 *)new OpenBabel::OBFFCalculation2(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation3_c_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->c = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation3_c_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->c); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation3_idx_c_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  arg2 = (int)jarg2;  if (arg1) (arg1)->idx_c = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFCalculation3_idx_c_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; int result;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  result = (int) ((arg1)->idx_c); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation3_pos_c_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; double *arg2 = (double *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  arg2 = (double *)jarg2;  if (arg1) (arg1)->pos_c = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation3_pos_c_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  result = (double *) ((arg1)->pos_c); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation3_force_c_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; double *arg2 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  arg2 = (double *)jarg2;  { size_t ii; double *b = (double *) arg1->force_c;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((double *) arg2 + ii); }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation3_force_c_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation3 *)jarg1;  result = (double *)(double *) ((arg1)->force_c); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFCalculation3(void * jarg1) {
  OpenBabel::OBFFCalculation3 *arg1 = (OpenBabel::OBFFCalculation3 *) 0 ; arg1 = (OpenBabel::OBFFCalculation3 *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFCalculation3() { void * jresult ; OpenBabel::OBFFCalculation3 *result = 0 ;
  result = (OpenBabel::OBFFCalculation3 *)new OpenBabel::OBFFCalculation3(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation4_d_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->d = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation4_d_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->d); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation4_idx_d_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  arg2 = (int)jarg2;  if (arg1) (arg1)->idx_d = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFCalculation4_idx_d_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; int result;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  result = (int) ((arg1)->idx_d); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation4_pos_d_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; double *arg2 = (double *) 0 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  arg2 = (double *)jarg2;  if (arg1) (arg1)->pos_d = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation4_pos_d_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  result = (double *) ((arg1)->pos_d); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFCalculation4_force_d_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; double *arg2 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  arg2 = (double *)jarg2;  { size_t ii; double *b = (double *) arg1->force_d;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((double *) arg2 + ii); }  }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFCalculation4_force_d_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBFFCalculation4 *)jarg1;  result = (double *)(double *) ((arg1)->force_d); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFCalculation4(void * jarg1) {
  OpenBabel::OBFFCalculation4 *arg1 = (OpenBabel::OBFFCalculation4 *) 0 ; arg1 = (OpenBabel::OBFFCalculation4 *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFCalculation4() { void * jresult ; OpenBabel::OBFFCalculation4 *result = 0 ;
  result = (OpenBabel::OBFFCalculation4 *)new OpenBabel::OBFFCalculation4(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_factor_set(void * jarg1, double jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (double)jarg2;  if (arg1) (arg1)->factor = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraint_factor_get(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (double) ((arg1)->factor); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_constraint_value_set(void * jarg1, double jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (double)jarg2;  if (arg1) (arg1)->constraint_value = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraint_constraint_value_get(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (double) ((arg1)->constraint_value); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_rab0_set(void * jarg1, double jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (double)jarg2;  if (arg1) (arg1)->rab0 = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraint_rab0_get(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (double) ((arg1)->rab0); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_rbc0_set(void * jarg1, double jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (double)jarg2;  if (arg1) (arg1)->rbc0 = arg2; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraint_rbc0_get(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; double result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (double) ((arg1)->rbc0); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_type_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->type = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraint_type_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (int) ((arg1)->type); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_ia_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->ia = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraint_ia_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (int) ((arg1)->ia); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_ib_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->ib = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraint_ib_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (int) ((arg1)->ib); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_ic_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->ic = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraint_ic_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (int) ((arg1)->ic); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_id_set(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  arg2 = (int)jarg2;  if (arg1) (arg1)->id = arg2; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraint_id_get(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraint *)jarg1; 
  result = (int) ((arg1)->id); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_a_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->a = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_a_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->a); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_b_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->b = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_b_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->b); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_c_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->c = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_c_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->c); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_d_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  if (arg1) (arg1)->d = arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_d_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::OBAtom *) ((arg1)->d); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_grada_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *arg2 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2;  if (arg1) (arg1)->grada = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_grada_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::vector3 *)& ((arg1)->grada); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_gradb_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *arg2 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2;  if (arg1) (arg1)->gradb = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_gradb_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::vector3 *)& ((arg1)->gradb); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_gradc_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *arg2 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2;  if (arg1) (arg1)->gradc = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_gradc_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::vector3 *)& ((arg1)->gradc); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraint_gradd_set(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *arg2 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2;  if (arg1) (arg1)->gradd = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_gradd_get(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  result = (OpenBabel::vector3 *)& ((arg1)->gradd); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFConstraint() { void * jresult ; OpenBabel::OBFFConstraint *result = 0 ;
  result = (OpenBabel::OBFFConstraint *)new OpenBabel::OBFFConstraint(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFConstraint(void * jarg1) {
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; arg1 = (OpenBabel::OBFFConstraint *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraint_GetGradient(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBFFConstraint *arg1 = (OpenBabel::OBFFConstraint *) 0 ; int arg2 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->GetGradient(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBFFConstraints() { void * jresult ; OpenBabel::OBFFConstraints *result = 0 ;
  result = (OpenBabel::OBFFConstraints *)new OpenBabel::OBFFConstraints(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBFFConstraints(void * jarg1) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_Clear(void * jarg1) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  (arg1)->Clear(); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintEnergy(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; double result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  result = (double)(arg1)->GetConstraintEnergy(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraints_GetGradient(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->GetGradient(arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_Setup(void * jarg1, void * jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->Setup(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_SetFactor(void * jarg1, double jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (double)jarg2;  (arg1)->SetFactor(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddIgnore(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->AddIgnore(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddAtomConstraint(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->AddAtomConstraint(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddAtomXConstraint(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->AddAtomXConstraint(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddAtomYConstraint(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->AddAtomYConstraint(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddAtomZConstraint(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->AddAtomZConstraint(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddDistanceConstraint(void * jarg1, int jarg2, int jarg3, double jarg4) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (double)jarg4; 
  (arg1)->AddDistanceConstraint(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddAngleConstraint(void * jarg1, int jarg2, int jarg3, int jarg4, double jarg5) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int arg3 ; int arg4 ; double arg5 ;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  arg5 = (double)jarg5;  (arg1)->AddAngleConstraint(arg2,arg3,arg4,arg5); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_AddTorsionConstraint(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5, double jarg6) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ;
  double arg6 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  arg5 = (int)jarg5;  arg6 = (double)jarg6;  (arg1)->AddTorsionConstraint(arg2,arg3,arg4,arg5,arg6); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBFFConstraints_DeleteConstraint(void * jarg1, int jarg2) {
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->DeleteConstraint(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraints_GetFactor(void * jarg1) { double jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; double result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  result = (double)(arg1)->GetFactor(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_Size(void * jarg1) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int result; arg1 = (OpenBabel::OBFFConstraints *)jarg1; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->Size(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintType(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintType(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintValue(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (double)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintValue(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintAtomA(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintAtomA(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintAtomB(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintAtomB(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintAtomC(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintAtomC(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFFConstraints_GetConstraintAtomD(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; int result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2; 
  result = (int)((OpenBabel::OBFFConstraints const *)arg1)->GetConstraintAtomD(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFFConstraints_IsIgnored(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->IsIgnored(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFFConstraints_IsFixed(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->IsFixed(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFFConstraints_IsXFixed(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->IsXFixed(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFFConstraints_IsYFixed(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->IsYFixed(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBFFConstraints_IsZFixed(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->IsZFixed(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraints_GetIgnoredBitVec(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; OpenBabel::OBBitVec result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  result = (arg1)->GetIgnoredBitVec();
  jresult = new OpenBabel::OBBitVec((const OpenBabel::OBBitVec &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFFConstraints_GetFixedBitVec(void * jarg1) { void * jresult ;
  OpenBabel::OBFFConstraints *arg1 = (OpenBabel::OBFFConstraints *) 0 ; OpenBabel::OBBitVec result;
  arg1 = (OpenBabel::OBFFConstraints *)jarg1;  result = (arg1)->GetFixedBitVec();
  jresult = new OpenBabel::OBBitVec((const OpenBabel::OBBitVec &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_Default() { void * jresult ; OpenBabel::OBForceField **result = 0 ;
  result = (OpenBabel::OBForceField **) &OpenBabel::OBForceField::Default(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_FindType(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBForceField *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBForceField *)OpenBabel::OBForceField::FindType((char const *)arg1); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_MakeNewInstance(void * jarg1) { void * jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBForceField *result = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  result = (OpenBabel::OBForceField *)(arg1)->MakeNewInstance();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBForceField(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_FindForceField__SWIG_0(char * jarg1) { void * jresult ;
  std::string *arg1 = 0 ; OpenBabel::OBForceField *result = 0 ; if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg1_str(jarg1); arg1 = &arg1_str; 
  result = (OpenBabel::OBForceField *)OpenBabel::OBForceField::FindForceField((std::string const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetParameterFile(void * jarg1, char * jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  (arg1)->SetParameterFile((std::string const &)*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBForceField_GetUnit(void * jarg1) { char * jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; std::string result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (arg1)->GetUnit(); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_HasAnalyticalGradients(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->HasAnalyticalGradients(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_Setup__SWIG_0(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->Setup(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_Setup__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBFFConstraints *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg3 = (OpenBabel::OBFFConstraints *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBFFConstraints & type is null", 0);
    return 0; }   result = (bool)(arg1)->Setup(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_ParseParamFile(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->ParseParamFile(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetTypes(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->SetTypes(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetFormalCharges(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->SetFormalCharges(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetPartialCharges(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->SetPartialCharges(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetupCalculations(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->SetupCalculations(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetupPointers(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->SetupPointers(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_IsSetupNeeded(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->IsSetupNeeded(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_GetAtomTypes(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->GetAtomTypes(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_GetPartialCharges(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->GetPartialCharges(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_GetCoordinates(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->GetCoordinates(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_UpdateCoordinates(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->UpdateCoordinates(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_GetConformers(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->GetConformers(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_UpdateConformers(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->UpdateConformers(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetCoordinates(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->SetCoordinates(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetConformers(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->SetConformers(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_GetGrid(void * jarg1, double jarg2, double jarg3, char * jarg4, double jarg5) {
  void * jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double arg2 ; double arg3 ;
  char *arg4 = (char *) 0 ; double arg5 ; OpenBabel::OBGridData *result = 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (char *)jarg4;  arg5 = (double)jarg5; 
  result = (OpenBabel::OBGridData *)(arg1)->GetGrid(arg2,arg3,(char const *)arg4,arg5); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_AddIntraGroup(void * jarg1, void * jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->AddIntraGroup(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_AddInterGroup(void * jarg1, void * jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->AddInterGroup(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_AddInterGroups(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  OpenBabel::OBBitVec *arg3 = 0 ; arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    arg3 = (OpenBabel::OBBitVec *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->AddInterGroups(*arg2,*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ClearGroups(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->ClearGroups(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_HasGroups(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->HasGroups(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_EnableCutOff(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = jarg2 ? true : false;  (arg1)->EnableCutOff(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_IsCutOffEnabled(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->IsCutOffEnabled(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetVDWCutOff(void * jarg1, double jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetVDWCutOff(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_GetVDWCutOff(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->GetVDWCutOff(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetElectrostaticCutOff(void * jarg1, double jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetElectrostaticCutOff(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_GetElectrostaticCutOff(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->GetElectrostaticCutOff(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetUpdateFrequency(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetUpdateFrequency(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBForceField_GetUpdateFrequency(void * jarg1) { int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (int)(arg1)->GetUpdateFrequency(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_UpdatePairsSimple(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->UpdatePairsSimple(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_GetNumPairs(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (unsigned int)(arg1)->GetNumPairs(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_EnableAllPairs(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->EnableAllPairs(); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_Energy__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->Energy(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_Energy__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->Energy(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Bond__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_Bond(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Bond__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_Bond(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Angle__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_Angle(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Angle__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_Angle(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_StrBnd__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_StrBnd(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_StrBnd__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_StrBnd(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Torsion__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_Torsion(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Torsion__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_Torsion(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_OOP__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_OOP(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_OOP__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_OOP(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_VDW__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_VDW(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_VDW__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_VDW(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Electrostatic__SWIG_0(void * jarg1, unsigned int jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool arg2 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = jarg2 ? true : false;  result = (double)(arg1)->E_Electrostatic(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_E_Electrostatic__SWIG_1(void * jarg1) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (double)(arg1)->E_Electrostatic(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_PrintTypes(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->PrintTypes(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_PrintFormalCharges(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->PrintFormalCharges(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_PrintPartialCharges(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->PrintPartialCharges(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_PrintVelocities(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->PrintVelocities(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetLogFile(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; std::ostream *arg2 = (std::ostream *) 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (std::ostream *)jarg2;  result = (bool)(arg1)->SetLogFile(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SetLogLevel(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->SetLogLevel(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBForceField_GetLogLevel(void * jarg1) { int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (int)(arg1)->GetLogLevel(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_OBFFLog__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; std::string arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  if (!jarg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (arg1)->OBFFLog(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_DistanceGeometry(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->DistanceGeometry(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearch__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SystematicRotorSearch(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearch__SWIG_1(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->SystematicRotorSearch(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearchInitialize__SWIG_0(void * jarg1, unsigned int jarg2) {
  int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (int)(arg1)->SystematicRotorSearchInitialize(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearchInitialize__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (int)(arg1)->SystematicRotorSearchInitialize(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearchNextConformer__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(arg1)->SystematicRotorSearchNextConformer(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SystematicRotorSearchNextConformer__SWIG_1(void * jarg1) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  result = (bool)(arg1)->SystematicRotorSearchNextConformer(); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_RandomRotorSearch__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->RandomRotorSearch(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_RandomRotorSearch__SWIG_1(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->RandomRotorSearch(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_RandomRotorSearchInitialize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->RandomRotorSearchInitialize(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_RandomRotorSearchInitialize__SWIG_1(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->RandomRotorSearchInitialize(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_RandomRotorSearchNextConformer__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(arg1)->RandomRotorSearchNextConformer(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_RandomRotorSearchNextConformer__SWIG_1(void * jarg1) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  result = (bool)(arg1)->RandomRotorSearchNextConformer(); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_WeightedRotorSearch(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->WeightedRotorSearch(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetLineSearchType(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetLineSearchType(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBForceField_GetLineSearchType(void * jarg1) { int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (int)(arg1)->GetLineSearchType(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_LineSearch__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (arg1)->LineSearch(arg2,*arg3); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result); 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_LineSearch__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 0 ; double result; arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (double *)jarg2; 
  arg3 = (double *)jarg3;  result = (double)(arg1)->LineSearch(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_Newton2NumLineSearch(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double *arg2 = (double *) 0 ; double result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (double *)jarg2;  result = (double)(arg1)->Newton2NumLineSearch(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_LineSearchTakeStep(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double arg4 ; arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double)jarg4;  (arg1)->LineSearchTakeStep(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescent__SWIG_0(void * jarg1, int jarg2, double jarg3, int jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (int)jarg4; 
  (arg1)->SteepestDescent(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescent__SWIG_1(void * jarg1, int jarg2, double jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  (arg1)->SteepestDescent(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescent__SWIG_2(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SteepestDescent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescentInitialize__SWIG_0(void * jarg1, int jarg2, double jarg3, int jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (int)jarg4; 
  (arg1)->SteepestDescentInitialize(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescentInitialize__SWIG_1(void * jarg1, int jarg2, double jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3; 
  (arg1)->SteepestDescentInitialize(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescentInitialize__SWIG_2(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SteepestDescentInitialize(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SteepestDescentInitialize__SWIG_3(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->SteepestDescentInitialize(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_SteepestDescentTakeNSteps(void * jarg1, int jarg2) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->SteepestDescentTakeNSteps(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradients__SWIG_0(void * jarg1, int jarg2, double jarg3, int jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (int)jarg4; 
  (arg1)->ConjugateGradients(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradients__SWIG_1(void * jarg1, int jarg2, double jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  (arg1)->ConjugateGradients(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradients__SWIG_2(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->ConjugateGradients(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradientsInitialize__SWIG_0(void * jarg1, int jarg2, double jarg3, int jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (int)jarg4; 
  (arg1)->ConjugateGradientsInitialize(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradientsInitialize__SWIG_1(void * jarg1, int jarg2, double jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3; 
  (arg1)->ConjugateGradientsInitialize(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradientsInitialize__SWIG_2(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->ConjugateGradientsInitialize(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ConjugateGradientsInitialize__SWIG_3(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->ConjugateGradientsInitialize(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_ConjugateGradientsTakeNSteps(void * jarg1, int jarg2) {
  unsigned int jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  result = (bool)(arg1)->ConjugateGradientsTakeNSteps(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_GenerateVelocities(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->GenerateVelocities(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_CorrectVelocities(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->CorrectVelocities(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_MolecularDynamicsTakeNSteps__SWIG_0(void * jarg1, int jarg2, double jarg3, double jarg4, int jarg5) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; double arg4 ; int arg5 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  arg5 = (int)jarg5;  (arg1)->MolecularDynamicsTakeNSteps(arg2,arg3,arg4,arg5); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_MolecularDynamicsTakeNSteps__SWIG_1(void * jarg1, int jarg2, double jarg3, double jarg4) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (arg1)->MolecularDynamicsTakeNSteps(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_MolecularDynamicsTakeNSteps__SWIG_2(void * jarg1, int jarg2, double jarg3) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; double arg3 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (int)jarg2;  arg3 = (double)jarg3; 
  (arg1)->MolecularDynamicsTakeNSteps(arg2,arg3); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_GetConstraints(void * jarg1) { void * jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBFFConstraints *result = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  result = (OpenBabel::OBFFConstraints *) &(arg1)->GetConstraints();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetConstraints(void * jarg1, void * jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::OBFFConstraints *arg2 = 0 ;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBFFConstraints *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBFFConstraints & type is null", 0);
    return ; }   (arg1)->SetConstraints(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetFixAtom(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetFixAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_UnsetFixAtom(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->UnsetFixAtom(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_SetIgnoreAtom(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->SetIgnoreAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_UnsetIgnoreAtom(void * jarg1) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  (arg1)->UnsetIgnoreAtom(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_IgnoreCalculation__SWIG_0(int jarg1, int jarg2) { unsigned int jresult ;
  int arg1 ; int arg2 ; bool result; arg1 = (int)jarg1;  arg2 = (int)jarg2; 
  result = (bool)OpenBabel::OBForceField::IgnoreCalculation(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_IgnoreCalculation__SWIG_1(int jarg1, int jarg2, int jarg3) {
  unsigned int jresult ; int arg1 ; int arg2 ; int arg3 ; bool result; arg1 = (int)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  result = (bool)OpenBabel::OBForceField::IgnoreCalculation(arg1,arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_IgnoreCalculation__SWIG_2(int jarg1, int jarg2, int jarg3, int jarg4) {
  unsigned int jresult ; int arg1 ; int arg2 ; int arg3 ; int arg4 ; bool result; arg1 = (int)jarg1;  arg2 = (int)jarg2; 
  arg3 = (int)jarg3;  arg4 = (int)jarg4;  result = (bool)OpenBabel::OBForceField::IgnoreCalculation(arg1,arg2,arg3,arg4);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_DetectExplosion(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->DetectExplosion(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_ValidateLineSearch(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBForceField *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (arg1)->ValidateLineSearch(arg2,*arg3); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ValidateSteepestDescent(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->ValidateSteepestDescent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_ValidateConjugateGradients(void * jarg1, int jarg2) {
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; int arg2 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->ValidateConjugateGradients(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_Validate(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->Validate(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBForceField_ValidateGradients(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; bool result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (bool)(arg1)->ValidateGradients(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBForceField_ValidateGradientError(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ; OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBForceField *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (arg1)->ValidateGradientError(*arg2,*arg3); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result); 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorBondDerivative(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4;  result = (double)OpenBabel::OBForceField::VectorBondDerivative(arg1,arg2,arg3,arg4);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorDistanceDerivative(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; double *arg1 = (double *) (double *)0 ; double *arg2 = (double *) (double *)0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4; 
  result = (double)OpenBabel::OBForceField::VectorDistanceDerivative((double const *)arg1,(double const *)arg2,arg3,arg4);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorLengthDerivative(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (double)OpenBabel::OBForceField::VectorLengthDerivative(*arg1,*arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorAngleDerivative__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double *arg5 = (double *) 0 ; double *arg6 = (double *) 0 ; double result;
  arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  arg4 = (double *)jarg4;  arg5 = (double *)jarg5; 
  arg6 = (double *)jarg6;  result = (double)OpenBabel::OBForceField::VectorAngleDerivative(arg1,arg2,arg3,arg4,arg5,arg6);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorAngleDerivative__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ; double result;
  arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (double)OpenBabel::OBForceField::VectorAngleDerivative(*arg1,*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorOOPDerivative__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double *arg5 = (double *) 0 ; double *arg6 = (double *) 0 ; double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4;  arg5 = (double *)jarg5;  arg6 = (double *)jarg6;  arg7 = (double *)jarg7;  arg8 = (double *)jarg8; 
  result = (double)OpenBabel::OBForceField::VectorOOPDerivative(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorOOPDerivative__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ;
  OpenBabel::vector3 *arg4 = 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (double)OpenBabel::OBForceField::VectorOOPDerivative(*arg1,*arg2,*arg3,*arg4); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorTorsionDerivative__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double *arg5 = (double *) 0 ; double *arg6 = (double *) 0 ; double *arg7 = (double *) 0 ;
  double *arg8 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4;  arg5 = (double *)jarg5;  arg6 = (double *)jarg6;  arg7 = (double *)jarg7;  arg8 = (double *)jarg8; 
  result = (double)OpenBabel::OBForceField::VectorTorsionDerivative(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorTorsionDerivative__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; OpenBabel::vector3 *arg1 = 0 ; OpenBabel::vector3 *arg2 = 0 ; OpenBabel::vector3 *arg3 = 0 ;
  OpenBabel::vector3 *arg4 = 0 ; double result; arg1 = (OpenBabel::vector3 *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg2 = (OpenBabel::vector3 *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg3 = (OpenBabel::vector3 *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (double)OpenBabel::OBForceField::VectorTorsionDerivative(*arg1,*arg2,*arg3,*arg4); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorSubtract(void * jarg1, void * jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; arg1 = (double *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  OpenBabel::OBForceField::VectorSubtract(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorAdd(void * jarg1, void * jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; arg1 = (double *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  OpenBabel::OBForceField::VectorAdd(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorDivide(void * jarg1, double jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ; double arg2 ; double *arg3 = (double *) 0 ; arg1 = (double *)jarg1;  arg2 = (double)jarg2; 
  arg3 = (double *)jarg3;  OpenBabel::OBForceField::VectorDivide(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorMultiply(void * jarg1, double jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ; double arg2 ; double *arg3 = (double *) 0 ; arg1 = (double *)jarg1;  arg2 = (double)jarg2; 
  arg3 = (double *)jarg3;  OpenBabel::OBForceField::VectorMultiply(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorSelfMultiply(void * jarg1, double jarg2) { double *arg1 = (double *) 0 ;
  double arg2 ; arg1 = (double *)jarg1;  arg2 = (double)jarg2;  OpenBabel::OBForceField::VectorSelfMultiply(arg1,arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorNormalize(void * jarg1) { double *arg1 = (double *) 0 ;
  arg1 = (double *)jarg1;  OpenBabel::OBForceField::VectorNormalize(arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorCopy(void * jarg1, void * jarg2) { double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ; arg1 = (double *)jarg1;  arg2 = (double *)jarg2; 
  OpenBabel::OBForceField::VectorCopy(arg1,arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorLength(void * jarg1) { double jresult ; double *arg1 = (double *) 0 ;
  double result; arg1 = (double *)jarg1;  result = (double)OpenBabel::OBForceField::VectorLength(arg1); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorDistance(void * jarg1, void * jarg2) { double jresult ;
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2; 
  result = (double)OpenBabel::OBForceField::VectorDistance(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorAngle(void * jarg1, void * jarg2, void * jarg3) { double jresult ;
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; double result;
  arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  result = (double)OpenBabel::OBForceField::VectorAngle(arg1,arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorTorsion(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4;  result = (double)OpenBabel::OBForceField::VectorTorsion(arg1,arg2,arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorOOP(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  double jresult ; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ;
  double *arg4 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3; 
  arg4 = (double *)jarg4;  result = (double)OpenBabel::OBForceField::VectorOOP(arg1,arg2,arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorClear(void * jarg1) { double *arg1 = (double *) 0 ;
  arg1 = (double *)jarg1;  OpenBabel::OBForceField::VectorClear(arg1); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBForceField_VectorDot(void * jarg1, void * jarg2) { double jresult ;
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double result; arg1 = (double *)jarg1;  arg2 = (double *)jarg2; 
  result = (double)OpenBabel::OBForceField::VectorDot(arg1,arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_VectorCross(void * jarg1, void * jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; double *arg3 = (double *) 0 ; arg1 = (double *)jarg1; 
  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  OpenBabel::OBForceField::VectorCross(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBForceField_PrintVector(void * jarg1) { double *arg1 = (double *) 0 ;
  arg1 = (double *)jarg1;  OpenBabel::OBForceField::PrintVector(arg1); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBuilder() { void * jresult ; OpenBabel::OBBuilder *result = 0 ;
  result = (OpenBabel::OBBuilder *)new OpenBabel::OBBuilder(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Build(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBBuilder *arg1 = (OpenBabel::OBBuilder *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBBuilder *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->Build(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_SetKeepRings(void * jarg1) {
  OpenBabel::OBBuilder *arg1 = (OpenBabel::OBBuilder *) 0 ; arg1 = (OpenBabel::OBBuilder *)jarg1;  (arg1)->SetKeepRings(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_UnsetKeepRings(void * jarg1) {
  OpenBabel::OBBuilder *arg1 = (OpenBabel::OBBuilder *) 0 ; arg1 = (OpenBabel::OBBuilder *)jarg1;  (arg1)->UnsetKeepRings(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_LoadFragments(void * jarg1) {
  OpenBabel::OBBuilder *arg1 = (OpenBabel::OBBuilder *) 0 ; arg1 = (OpenBabel::OBBuilder *)jarg1;  (arg1)->LoadFragments(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBuilder_GetNewBondVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::vector3 result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = OpenBabel::OBBuilder::GetNewBondVector(arg1); jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBuilder_GetNewBondVector__SWIG_1(void * jarg1, double jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double arg2 ; OpenBabel::vector3 result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (double)jarg2;  result = OpenBabel::OBBuilder::GetNewBondVector(arg1,arg2);
  jresult = new OpenBabel::vector3((const OpenBabel::vector3 &)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Connect__SWIG_0(void * jarg1, int jarg2, int jarg3, void * jarg4, int jarg5) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = 0 ; int arg2 ; int arg3 ; OpenBabel::vector3 *arg4 = 0 ; int arg5 ;
  bool result; arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    arg5 = (int)jarg5;  result = (bool)OpenBabel::OBBuilder::Connect(*arg1,arg2,arg3,*arg4,arg5); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Connect__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = 0 ; int arg2 ; int arg3 ; OpenBabel::vector3 *arg4 = 0 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (OpenBabel::vector3 *)jarg4; if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 & type is null", 0); return 0; }
    result = (bool)OpenBabel::OBBuilder::Connect(*arg1,arg2,arg3,*arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Connect__SWIG_2(void * jarg1, int jarg2, int jarg3, int jarg4) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = 0 ; int arg2 ; int arg3 ; int arg4 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  result = (bool)OpenBabel::OBBuilder::Connect(*arg1,arg2,arg3,arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Connect__SWIG_3(void * jarg1, int jarg2, int jarg3) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = 0 ; int arg2 ; int arg3 ; bool result; arg1 = (OpenBabel::OBMol *)jarg1;
  if (!arg1) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0);
    return 0; }   arg2 = (int)jarg2;  arg3 = (int)jarg3;  result = (bool)OpenBabel::OBBuilder::Connect(*arg1,arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_Swap(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
  unsigned int jresult ; OpenBabel::OBMol *arg1 = 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; bool result;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    arg2 = (int)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4;  arg5 = (int)jarg5; 
  result = (bool)OpenBabel::OBBuilder::Swap(*arg1,arg2,arg3,arg4,arg5); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_CorrectStereoBonds(void * jarg1) { OpenBabel::OBMol *arg1 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  OpenBabel::OBBuilder::CorrectStereoBonds(*arg1); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_CorrectStereoAtoms(void * jarg1) { OpenBabel::OBMol *arg1 = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  OpenBabel::OBBuilder::CorrectStereoAtoms(*arg1); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBuilder_IsSpiroAtom(unsigned long jarg1, void * jarg2) { unsigned int jresult ;
  unsigned long arg1 ; OpenBabel::OBMol *arg2 = 0 ; bool result; arg1 = (unsigned long)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;
  if (!arg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0);
    return 0; }   result = (bool)OpenBabel::OBBuilder::IsSpiroAtom(arg1,*arg2); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBuilder_GetFragment(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBitVec result; arg1 = (OpenBabel::OBAtom *)jarg1; 
  result = OpenBabel::OBBuilder::GetFragment(arg1); jresult = new OpenBabel::OBBitVec((const OpenBabel::OBBitVec &)result); 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBuilder_AddNbrs(void * jarg1, void * jarg2) { OpenBabel::OBBitVec *arg1 = 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; arg1 = (OpenBabel::OBBitVec *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    arg2 = (OpenBabel::OBAtom *)jarg2;  OpenBabel::OBBuilder::AddNbrs(*arg1,arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBBuilder(void * jarg1) { OpenBabel::OBBuilder *arg1 = (OpenBabel::OBBuilder *) 0 ;
  arg1 = (OpenBabel::OBBuilder *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBOp_Default() { void * jresult ; OpenBabel::OBOp **result = 0 ;
  result = (OpenBabel::OBOp **) &OpenBabel::OBOp::Default(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBOp_FindType(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBOp *result = 0 ; arg1 = (char *)jarg1; 
  result = (OpenBabel::OBOp *)OpenBabel::OBOp::FindType((char const *)arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_0(void * jarg1, void * jarg2, char * jarg3, void * jarg4, void * jarg5) {
  unsigned int jresult ; OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  char *arg3 = (char *) 0 ; OpenBabel::OBOp::OpMap *arg4 = (OpenBabel::OBOp::OpMap *) 0 ;
  OpenBabel::OBConversion *arg5 = (OpenBabel::OBConversion *) 0 ; bool result; arg1 = (OpenBabel::OBOp *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (char *)jarg3;  arg4 = (OpenBabel::OBOp::OpMap *)jarg4; 
  arg5 = (OpenBabel::OBConversion *)jarg5;  result = (bool)(arg1)->Do(arg2,(char const *)arg3,arg4,arg5); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_1(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  char *arg3 = (char *) 0 ; OpenBabel::OBOp::OpMap *arg4 = (OpenBabel::OBOp::OpMap *) 0 ; bool result;
  arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (char *)jarg3; 
  arg4 = (OpenBabel::OBOp::OpMap *)jarg4;  result = (bool)(arg1)->Do(arg2,(char const *)arg3,arg4); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_2(void * jarg1, void * jarg2, char * jarg3) { unsigned int jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; char *arg3 = (char *) 0 ;
  bool result; arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->Do(arg2,(char const *)arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_3(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; bool result;
  arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  result = (bool)(arg1)->Do(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_WorksWith(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; bool result;
  arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (bool)((OpenBabel::OBOp const *)arg1)->WorksWith(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_ProcessVec(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; std::vector< OpenBabel::OBBase * > *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (std::vector< OpenBabel::OBBase * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBase * > & type is null", 0);
    return 0; }   result = (bool)(arg1)->ProcessVec(*arg2); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBOp_OpOptions(void * jarg1) { char * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; std::string result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = OpenBabel::OBOp::OpOptions(arg1); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_DoOps(void * jarg1, void * jarg2, void * jarg3) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBOp::OpMap *arg2 = (OpenBabel::OBOp::OpMap *) 0 ;
  OpenBabel::OBConversion *arg3 = (OpenBabel::OBConversion *) 0 ; bool result; arg1 = (OpenBabel::OBBase *)jarg1; 
  arg2 = (OpenBabel::OBOp::OpMap *)jarg2;  arg3 = (OpenBabel::OBConversion *)jarg3; 
  result = (bool)OpenBabel::OBOp::DoOps(arg1,(std::map< std::string,std::string > const *)arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBOp(void * jarg1) { OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ;
  arg1 = (OpenBabel::OBOp *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBitVec__SWIG_0() { void * jresult ; OpenBabel::OBBitVec *result = 0 ;
  result = (OpenBabel::OBBitVec *)new OpenBabel::OBBitVec(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBitVec__SWIG_1(unsigned int jarg1) { void * jresult ; unsigned int arg1 ;
  OpenBabel::OBBitVec *result = 0 ; arg1 = (unsigned int)jarg1;  result = (OpenBabel::OBBitVec *)new OpenBabel::OBBitVec(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBBitVec__SWIG_2(void * jarg1) { void * jresult ; OpenBabel::OBBitVec *arg1 = 0 ;
  OpenBabel::OBBitVec *result = 0 ; arg1 = (OpenBabel::OBBitVec *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec const & type is null", 0);
    return 0; }   result = (OpenBabel::OBBitVec *)new OpenBabel::OBBitVec((OpenBabel::OBBitVec const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_SetBitOn(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetBitOn(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_SetBitOff(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->SetBitOff(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_SetRangeOn(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->SetRangeOn(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_SetRangeOff(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; unsigned int arg3 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  arg2 = (unsigned int)jarg2;  arg3 = (unsigned int)jarg3; 
  (arg1)->SetRangeOff(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_Fold(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->Fold(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBBitVec_FirstBit__SWIG_0(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; int result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (int)((OpenBabel::OBBitVec const *)arg1)->FirstBit(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBBitVec_FirstBit__SWIG_1(void * jarg1) { int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; int result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = (int)((OpenBabel::OBBitVec const *)arg1)->FirstBit(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBBitVec_NextBit(void * jarg1, int jarg2) { int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; int arg2 ; int result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (int)jarg2;  result = (int)((OpenBabel::OBBitVec const *)arg1)->NextBit(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBBitVec_EndBit(void * jarg1) { int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; int result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = (int)((OpenBabel::OBBitVec const *)arg1)->EndBit(); jresult = result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBBitVec_GetSize(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; size_t result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = ((OpenBabel::OBBitVec const *)arg1)->GetSize(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_CountBits(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBitVec const *)arg1)->CountBits(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_Empty(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = (bool)((OpenBabel::OBBitVec const *)arg1)->Empty(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_IsEmpty(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  result = (bool)((OpenBabel::OBBitVec const *)arg1)->IsEmpty(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_Resize(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (bool)(arg1)->Resize(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_ResizeWords(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (bool)(arg1)->ResizeWords(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_BitIsSet(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; unsigned int arg2 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (unsigned int)jarg2;  result = (bool)((OpenBabel::OBBitVec const *)arg1)->BitIsSet(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBBitVec_BitIsOn(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; int arg2 ; bool result; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (int)jarg2;  result = (bool)((OpenBabel::OBBitVec const *)arg1)->BitIsOn(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_FromVecInt(void * jarg1, void * jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   (arg1)->FromVecInt((std::vector< int > const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_FromString(void * jarg1, char * jarg2, int jarg3) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; std::string *arg2 = 0 ; int arg3 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  std::string arg2_str(jarg2); arg2 = &arg2_str;  arg3 = (int)jarg3;  (arg1)->FromString((std::string const &)*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_ToVecInt(void * jarg1, void * jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (OpenBabel::OBBitVec *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return ; }
    ((OpenBabel::OBBitVec const *)arg1)->ToVecInt(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_Clear(void * jarg1) { OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_Negate(void * jarg1) { OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  (arg1)->Negate(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBBitVec_GetWords(void * jarg1, void * jarg2) {
  OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ; OpenBabel::OBBitVec::word_vector *arg2 = 0 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  arg2 = (OpenBabel::OBBitVec::word_vector *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec::word_vector & type is null", 0);
    return ; }   (arg1)->GetWords(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBBitVec(void * jarg1) { OpenBabel::OBBitVec *arg1 = (OpenBabel::OBBitVec *) 0 ;
  arg1 = (OpenBabel::OBBitVec *)jarg1;  delete arg1; }
SWIGEXPORT double SWIGSTDCALL CSharp_Tanimoto(void * jarg1, void * jarg2) { double jresult ; OpenBabel::OBBitVec *arg1 = 0 ;
  OpenBabel::OBBitVec *arg2 = 0 ; double result; arg1 = (OpenBabel::OBBitVec *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec const & type is null", 0);
    return 0; }   arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec const & type is null", 0);
    return 0; }   result = (double)OpenBabel::Tanimoto((OpenBabel::OBBitVec const &)*arg1,(OpenBabel::OBBitVec const &)*arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotorRule(char * jarg1, void * jarg2, void * jarg3, double jarg4) { void * jresult ;
  char *arg1 = (char *) 0 ; int *arg2 ; std::vector< double > *arg3 = 0 ; double arg4 ; OpenBabel::OBRotorRule *result = 0 ;
  arg1 = (char *)jarg1;  arg2 = (int *)jarg2;  arg3 = (std::vector< double > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > & type is null", 0);
    return 0; }   arg4 = (double)jarg4;  result = (OpenBabel::OBRotorRule *)new OpenBabel::OBRotorRule(arg1,arg2,*arg3,arg4);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotorRule(void * jarg1) {
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; arg1 = (OpenBabel::OBRotorRule *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorRule_IsValid(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; bool result; arg1 = (OpenBabel::OBRotorRule *)jarg1; 
  result = (bool)(arg1)->IsValid(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorRule_GetReferenceAtoms(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; int *arg2 ; arg1 = (OpenBabel::OBRotorRule *)jarg1; 
  arg2 = (int *)jarg2;  (arg1)->GetReferenceAtoms(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorRule_SetDelta(void * jarg1, double jarg2) {
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; double arg2 ; arg1 = (OpenBabel::OBRotorRule *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetDelta(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBRotorRule_GetDelta(void * jarg1) { double jresult ;
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; double result; arg1 = (OpenBabel::OBRotorRule *)jarg1; 
  result = (double)(arg1)->GetDelta(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotorRule_GetTorsionVals(void * jarg1) { void * jresult ;
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; std::vector< double > *result = 0 ;
  arg1 = (OpenBabel::OBRotorRule *)jarg1;  result = (std::vector< double > *) &(arg1)->GetTorsionVals();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotorRule_GetSmartsString(void * jarg1) { void * jresult ;
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; std::string *result = 0 ;
  arg1 = (OpenBabel::OBRotorRule *)jarg1;  result = (std::string *) &(arg1)->GetSmartsString(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotorRule_GetSmartsPattern(void * jarg1) { void * jresult ;
  OpenBabel::OBRotorRule *arg1 = (OpenBabel::OBRotorRule *) 0 ; OpenBabel::OBSmartsPattern *result = 0 ;
  arg1 = (OpenBabel::OBRotorRule *)jarg1;  result = (OpenBabel::OBSmartsPattern *)(arg1)->GetSmartsPattern();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotorRules() { void * jresult ; OpenBabel::OBRotorRules *result = 0 ;
  result = (OpenBabel::OBRotorRules *)new OpenBabel::OBRotorRules(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotorRules(void * jarg1) {
  OpenBabel::OBRotorRules *arg1 = (OpenBabel::OBRotorRules *) 0 ; arg1 = (OpenBabel::OBRotorRules *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorRules_SetFilename(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorRules *arg1 = (OpenBabel::OBRotorRules *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotorRules *)jarg1;  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  (arg1)->SetFilename(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorRules_GetRotorIncrements(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  OpenBabel::OBRotorRules *arg1 = (OpenBabel::OBRotorRules *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; int *arg4 ; std::vector< double > *arg5 = 0 ; double *arg6 = 0 ;
  arg1 = (OpenBabel::OBRotorRules *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = (OpenBabel::OBBond *)jarg3;  arg4 = (int *)jarg4;  arg5 = (std::vector< double > *)jarg5; if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > & type is null", 0);
    return ; }   arg6 = (double *)jarg6; if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "double & type is null", 0); return ; }  
  (arg1)->GetRotorIncrements(*arg2,arg3,arg4,*arg5,*arg6); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorRules_Quiet(void * jarg1) {
  OpenBabel::OBRotorRules *arg1 = (OpenBabel::OBRotorRules *) 0 ; arg1 = (OpenBabel::OBRotorRules *)jarg1;  (arg1)->Quiet(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotor() { void * jresult ; OpenBabel::OBRotor *result = 0 ;
  result = (OpenBabel::OBRotor *)new OpenBabel::OBRotor(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotor(void * jarg1) { OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetBond(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (arg1)->SetBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetDihedralAtoms__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return ; }
    (arg1)->SetDihedralAtoms(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetDihedralAtoms__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int *arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (int *)jarg2; 
  (arg1)->SetDihedralAtoms(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetRotAtoms(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > & type is null", 0); return ; }
    (arg1)->SetRotAtoms(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetTorsionValues(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< double > *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (std::vector< double > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > & type is null", 0);
    return ; }   (arg1)->SetTorsionValues(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetFixedBonds(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->SetFixedBonds(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetToAngle(void * jarg1, void * jarg2, double jarg3) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; double arg3 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double)jarg3;  (arg1)->SetToAngle(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetRotor__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; int arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  (arg1)->SetRotor(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetRotor__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; int arg3 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  (arg1)->SetRotor(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_Set__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; double arg3 ; double arg4 ; double arg5 ;
  double arg6 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  arg5 = (double)jarg5;  arg6 = (double)jarg6;  (arg1)->Set(arg2,arg3,arg4,arg5,arg6); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_Precompute(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->Precompute(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_Set__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; int arg3 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  (arg1)->Set(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_Precalc(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< double * > *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (std::vector< double * > *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double * > & type is null", 0);
    return ; }   (arg1)->Precalc(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_Set__SWIG_2(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; int arg3 ; int arg4 ;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  arg3 = (int)jarg3;  arg4 = (int)jarg4; 
  (arg1)->Set(arg2,arg3,arg4); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetBond(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (OpenBabel::OBBond *)(arg1)->GetBond(); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBRotor_Size(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; size_t result; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (arg1)->Size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRotor_GetIdx(void * jarg1) { int jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int result; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (int)((OpenBabel::OBRotor const *)arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_GetDihedralAtoms__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int *arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (int *)jarg2; 
  (arg1)->GetDihedralAtoms(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetDihedralAtoms__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< int > *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (std::vector< int > *) &(arg1)->GetDihedralAtoms(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetTorsionValues(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< double > *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (std::vector< double > *) &((OpenBabel::OBRotor const *)arg1)->GetTorsionValues(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetFixedBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (OpenBabel::OBBitVec *) &(arg1)->GetFixedBonds(); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBRotor_CalcTorsion(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; double result;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  result = (double)(arg1)->CalcTorsion(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBRotor_CalcBondLength(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double *arg2 = (double *) 0 ; double result;
  arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (double *)jarg2;  result = (double)(arg1)->CalcBondLength(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_BeginTorIncrement(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; SwigValueWrapper< std::vector< double >::iterator > result;
  arg1 = (OpenBabel::OBRotor *)jarg1;  result = (arg1)->BeginTorIncrement();
  jresult = new std::vector< double >::iterator((const std::vector< double >::iterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_EndTorIncrement(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; SwigValueWrapper< std::vector< double >::iterator > result;
  arg1 = (OpenBabel::OBRotor *)jarg1;  result = (arg1)->EndTorIncrement();
  jresult = new std::vector< double >::iterator((const std::vector< double >::iterator &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_RemoveSymTorsionValues(void * jarg1, int jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->RemoveSymTorsionValues(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetDelta(void * jarg1, double jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetDelta(arg2); }
SWIGEXPORT double SWIGSTDCALL CSharp_OBRotor_GetDelta(void * jarg1) { double jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; double result; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (double)(arg1)->GetDelta(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetFixedAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (OpenBabel::OBBitVec *) &(arg1)->GetFixedAtoms(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetFixedAtoms(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->SetFixedAtoms(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetEvalAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (OpenBabel::OBBitVec *) &(arg1)->GetEvalAtoms(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetEvalAtoms(void * jarg1, void * jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->SetEvalAtoms(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotor_GetResolution(void * jarg1) { void * jresult ;
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; std::vector< double > *result = 0 ; arg1 = (OpenBabel::OBRotor *)jarg1; 
  result = (std::vector< double > *) &(arg1)->GetResolution(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotor_SetNumCoords(void * jarg1, int jarg2) {
  OpenBabel::OBRotor *arg1 = (OpenBabel::OBRotor *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRotor *)jarg1;  arg2 = (int)jarg2; 
  (arg1)->SetNumCoords(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotorList() { void * jresult ; OpenBabel::OBRotorList *result = 0 ;
  result = (OpenBabel::OBRotorList *)new OpenBabel::OBRotorList(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotorList(void * jarg1) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; arg1 = (OpenBabel::OBRotorList *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_Clear(void * jarg1) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; arg1 = (OpenBabel::OBRotorList *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_OBRotorList_Size(void * jarg1) { unsigned long jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; size_t result; arg1 = (OpenBabel::OBRotorList *)jarg1; 
  result = (arg1)->Size(); jresult = (unsigned long)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_IsFixedBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  result = (bool)(arg1)->IsFixedBond(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_HasFixedBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; bool result; arg1 = (OpenBabel::OBRotorList *)jarg1; 
  result = (bool)(arg1)->HasFixedBonds(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_RemoveSymVals(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->RemoveSymVals(*arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_Setup(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->Setup(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_SetFixedBonds(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->SetFixedBonds(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_Init(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBRotorList *)jarg1; 
  arg2 = (std::string *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  (arg1)->Init(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_SetQuiet(void * jarg1) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; arg1 = (OpenBabel::OBRotorList *)jarg1;  (arg1)->SetQuiet(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_SetRotAtoms(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->SetRotAtoms(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_FindRotors(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->FindRotors(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_SetEvalAtoms(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->SetEvalAtoms(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_AssignTorVals(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->AssignTorVals(*arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_IdentifyEvalAtoms(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (bool)(arg1)->IdentifyEvalAtoms(*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_SetFixAtoms(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec & type is null", 0); return ; }
    (arg1)->SetFixAtoms(*arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorList_HasFixedAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; bool result; arg1 = (OpenBabel::OBRotorList *)jarg1; 
  result = (bool)(arg1)->HasFixedAtoms(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_IgnoreSymmetryRemoval(void * jarg1) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; arg1 = (OpenBabel::OBRotorList *)jarg1; 
  (arg1)->IgnoreSymmetryRemoval(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorList_SetRotAtomsByFix(void * jarg1, void * jarg2) {
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->SetRotAtomsByFix(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotorList_GetRotors(void * jarg1) { void * jresult ;
  OpenBabel::OBRotorList *arg1 = (OpenBabel::OBRotorList *) 0 ; std::vector< OpenBabel::OBRotor * > result;
  arg1 = (OpenBabel::OBRotorList *)jarg1;  result = OpenBabel_OBRotorList_GetRotors(arg1);
  jresult = new std::vector< OpenBabel::OBRotor * >((const std::vector< OpenBabel::OBRotor * > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_rotor_digit__SWIG_0(unsigned int jarg1) { void * jresult ; unsigned int arg1 ;
  OpenBabel::rotor_digit *result = 0 ; arg1 = (unsigned int)jarg1; 
  result = (OpenBabel::rotor_digit *)new OpenBabel::rotor_digit(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_rotor_digit__SWIG_1() { void * jresult ; OpenBabel::rotor_digit *result = 0 ;
  result = (OpenBabel::rotor_digit *)new OpenBabel::rotor_digit(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_rotor_digit_set_size(void * jarg1, unsigned int jarg2) {
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::rotor_digit *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->set_size(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_rotor_digit_set_state(void * jarg1, int jarg2) {
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; int arg2 ; arg1 = (OpenBabel::rotor_digit *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->set_state(arg2); }
SWIGEXPORT int SWIGSTDCALL CSharp_rotor_digit_get_state(void * jarg1) { int jresult ;
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; int result; arg1 = (OpenBabel::rotor_digit *)jarg1; 
  result = (int)(arg1)->get_state(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_rotor_digit_size(void * jarg1) { unsigned int jresult ;
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; unsigned int result; arg1 = (OpenBabel::rotor_digit *)jarg1; 
  result = (unsigned int)(arg1)->size(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_rotor_digit_next(void * jarg1) { unsigned int jresult ;
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; bool result; arg1 = (OpenBabel::rotor_digit *)jarg1; 
  result = (bool)(arg1)->next(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_rotor_digit(void * jarg1) {
  OpenBabel::rotor_digit *arg1 = (OpenBabel::rotor_digit *) 0 ; arg1 = (OpenBabel::rotor_digit *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotorKeys() { void * jresult ; OpenBabel::OBRotorKeys *result = 0 ;
  result = (OpenBabel::OBRotorKeys *)new OpenBabel::OBRotorKeys(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorKeys_Clear(void * jarg1) {
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; arg1 = (OpenBabel::OBRotorKeys *)jarg1;  (arg1)->Clear(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorKeys_NumKeys(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; unsigned int result; arg1 = (OpenBabel::OBRotorKeys *)jarg1; 
  result = (unsigned int)(arg1)->NumKeys(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotorKeys_AddRotor(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::OBRotorKeys *)jarg1; 
  arg2 = (unsigned int)jarg2;  (arg1)->AddRotor(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotorKeys_Next(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; bool result; arg1 = (OpenBabel::OBRotorKeys *)jarg1; 
  result = (bool)(arg1)->Next(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotorKeys_GetKey(void * jarg1) { void * jresult ;
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; std::vector< int > result;
  arg1 = (OpenBabel::OBRotorKeys *)jarg1;  result = (arg1)->GetKey();
  jresult = new std::vector< int >((const std::vector< int > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotorKeys(void * jarg1) {
  OpenBabel::OBRotorKeys *arg1 = (OpenBabel::OBRotorKeys *) 0 ; arg1 = (OpenBabel::OBRotorKeys *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBRotamerList() { void * jresult ; OpenBabel::OBRotamerList *result = 0 ;
  result = (OpenBabel::OBRotamerList *)new OpenBabel::OBRotamerList(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRotamerList(void * jarg1) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; arg1 = (OpenBabel::OBRotamerList *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_Setup__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBRotorList *arg3 = 0 ; arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = (OpenBabel::OBRotorList *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBRotorList & type is null", 0);
    return ; }   (arg1)->Setup(*arg2,*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_Setup__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ; int arg4 ; arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = (unsigned char *)jarg3;  arg4 = (int)jarg4;  (arg1)->Setup(*arg2,arg3,arg4); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotamerList_NumRotors(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  result = (unsigned int)((OpenBabel::OBRotamerList const *)arg1)->NumRotors();
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotamerList_NumRotamers(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  result = (unsigned int)((OpenBabel::OBRotamerList const *)arg1)->NumRotamers();
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_AddRotamer__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; double *arg2 = (double *) 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (double *)jarg2;  (arg1)->AddRotamer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_AddRotamer__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; int *arg2 = (int *) 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (int *)jarg2;  (arg1)->AddRotamer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_AddRotamer__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; std::vector< int > arg2 ; std::vector< int > *argp2 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  argp2 = (std::vector< int > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< int >", 0);
    return ; }  arg2 = *argp2;  (arg1)->AddRotamer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_AddRotamer__SWIG_3(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (unsigned char *)jarg2;  (arg1)->AddRotamer(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_AddRotamers(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (unsigned char *)jarg2;  arg3 = (int)jarg3; 
  (arg1)->AddRotamers(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_GetReferenceArray(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (unsigned char *)jarg2; 
  ((OpenBabel::OBRotamerList const *)arg1)->GetReferenceArray(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotamerList_BeginRotamer(void * jarg1) { void * jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ;
  SwigValueWrapper< std::vector< unsigned char * >::iterator > result; arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  result = (arg1)->BeginRotamer();
  jresult = new std::vector< unsigned char * >::iterator((const std::vector< unsigned char * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotamerList_EndRotamer(void * jarg1) { void * jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ;
  SwigValueWrapper< std::vector< unsigned char * >::iterator > result; arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  result = (arg1)->EndRotamer();
  jresult = new std::vector< unsigned char * >::iterator((const std::vector< unsigned char * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotamerList_CreateConformerList(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  SwigValueWrapper< std::vector< double * > > result; arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return 0; }
    result = (arg1)->CreateConformerList(*arg2);
  jresult = new std::vector< double * >((const std::vector< double * > &)result);  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_ExpandConformerList(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  std::vector< double * > *arg3 = 0 ; arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = (std::vector< double * > *)jarg3; if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double * > & type is null", 0);
    return ; }   (arg1)->ExpandConformerList(*arg2,*arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_SetCurrentCoordinates(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ; std::vector< int > arg3 ;
  std::vector< int > *argp3 ; arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  argp3 = (std::vector< int > *)jarg3;  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< int >", 0);
    return ; }  arg3 = *argp3;  (arg1)->SetCurrentCoordinates(*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_SetBaseCoordinateSets__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->SetBaseCoordinateSets(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRotamerList_SetBaseCoordinateSets__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; SwigValueWrapper< std::vector< double * > > arg2 ;
  unsigned int arg3 ; std::vector< double * > *argp2 ; arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  argp2 = (std::vector< double * > *)jarg2;  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double * >", 0);
    return ; }  arg2 = *argp2;  arg3 = (unsigned int)jarg3;  (arg1)->SetBaseCoordinateSets(arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotamerList_NumBaseCoordinateSets(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBRotamerList *)jarg1; 
  result = (unsigned int)((OpenBabel::OBRotamerList const *)arg1)->NumBaseCoordinateSets(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRotamerList_GetBaseCoordinateSet(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned int arg2 ; double *result = 0 ;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (double *)((OpenBabel::OBRotamerList const *)arg1)->GetBaseCoordinateSet(arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRotamerList_NumAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBRotamerList *arg1 = (OpenBabel::OBRotamerList *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBRotamerList *)jarg1;  result = (unsigned int)((OpenBabel::OBRotamerList const *)arg1)->NumAtoms();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolAtomIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolAtomIter *)new OpenBabel::OBMolAtomIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = 0 ; OpenBabel::OBMolAtomIter *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolAtomIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMolAtomIter *)new OpenBabel::OBMolAtomIter((OpenBabel::OBMolAtomIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolAtomIter(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)((OpenBabel::OBMolAtomIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBMolAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (OpenBabel::OBMolAtomIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; OpenBabel::OBMolAtomIter result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBMolAtomIter((const OpenBabel::OBMolAtomIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (OpenBabel::OBAtom *) &((OpenBabel::OBMolAtomIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomDFSIter__SWIG_0(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBMolAtomDFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBMolAtomDFSIter *)new OpenBabel::OBMolAtomDFSIter(arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomDFSIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolAtomDFSIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolAtomDFSIter *)new OpenBabel::OBMolAtomDFSIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomDFSIter__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = 0 ; OpenBabel::OBMolAtomDFSIter *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolAtomDFSIter const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBMolAtomDFSIter *)new OpenBabel::OBMolAtomDFSIter((OpenBabel::OBMolAtomDFSIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolAtomDFSIter(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)((OpenBabel::OBMolAtomDFSIter const *)arg1)->operator bool();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBMolAtomDFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (OpenBabel::OBMolAtomDFSIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ; OpenBabel::OBMolAtomDFSIter result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBMolAtomDFSIter((const OpenBabel::OBMolAtomDFSIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  result = (OpenBabel::OBAtom *) &((OpenBabel::OBMolAtomDFSIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_next(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (OpenBabel::OBAtom *)(arg1)->next(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomBFSIter__SWIG_0(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBMolAtomBFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBMolAtomBFSIter *)new OpenBabel::OBMolAtomBFSIter(arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomBFSIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolAtomBFSIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolAtomBFSIter *)new OpenBabel::OBMolAtomBFSIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomBFSIter__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = 0 ; OpenBabel::OBMolAtomBFSIter *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolAtomBFSIter const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBMolAtomBFSIter *)new OpenBabel::OBMolAtomBFSIter((OpenBabel::OBMolAtomBFSIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolAtomBFSIter(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)((OpenBabel::OBMolAtomBFSIter const *)arg1)->operator bool();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBMolAtomBFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (OpenBabel::OBMolAtomBFSIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ; OpenBabel::OBMolAtomBFSIter result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBMolAtomBFSIter((const OpenBabel::OBMolAtomBFSIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  result = (OpenBabel::OBAtom *) &((OpenBabel::OBMolAtomBFSIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomBFSIter_CurrentDepth(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (int)((OpenBabel::OBMolAtomBFSIter const *)arg1)->CurrentDepth();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondBFSIter__SWIG_0(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; int arg2 ; OpenBabel::OBMolBondBFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (int)jarg2; 
  result = (OpenBabel::OBMolBondBFSIter *)new OpenBabel::OBMolBondBFSIter(arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondBFSIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolBondBFSIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolBondBFSIter *)new OpenBabel::OBMolBondBFSIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondBFSIter__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = 0 ; OpenBabel::OBMolBondBFSIter *result = 0 ; arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolBondBFSIter const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBMolBondBFSIter *)new OpenBabel::OBMolBondBFSIter((OpenBabel::OBMolBondBFSIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolBondBFSIter(void * jarg1) {
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1; 
  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondBFSIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1;  result = (bool)((OpenBabel::OBMolBondBFSIter const *)arg1)->operator bool();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondBFSIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; OpenBabel::OBMolBondBFSIter *result = 0 ;
  arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1;  result = (OpenBabel::OBMolBondBFSIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondBFSIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; int arg2 ; OpenBabel::OBMolBondBFSIter result;
  arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBMolBondBFSIter((const OpenBabel::OBMolBondBFSIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondBFSIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1; 
  result = (OpenBabel::OBBond *) &((OpenBabel::OBMolBondBFSIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolBondBFSIter_CurrentDepth(void * jarg1) { int jresult ;
  OpenBabel::OBMolBondBFSIter *arg1 = (OpenBabel::OBMolBondBFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolBondBFSIter *)jarg1;  result = (int)((OpenBabel::OBMolBondBFSIter const *)arg1)->CurrentDepth();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolBondIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolBondIter *)new OpenBabel::OBMolBondIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = 0 ; OpenBabel::OBMolBondIter *result = 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolBondIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMolBondIter *)new OpenBabel::OBMolBondIter((OpenBabel::OBMolBondIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolBondIter(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)((OpenBabel::OBMolBondIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBMolBondIter *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (OpenBabel::OBMolBondIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; int arg2 ; OpenBabel::OBMolBondIter result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBMolBondIter((const OpenBabel::OBMolBondIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (OpenBabel::OBBond *) &((OpenBabel::OBMolBondIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomAtomIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtomAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  result = (OpenBabel::OBAtomAtomIter *)new OpenBabel::OBAtomAtomIter(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomAtomIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = 0 ; OpenBabel::OBAtomAtomIter *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtomAtomIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtomAtomIter *)new OpenBabel::OBAtomAtomIter((OpenBabel::OBAtomAtomIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAtomAtomIter(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)((OpenBabel::OBAtomAtomIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtomAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (OpenBabel::OBAtomAtomIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; OpenBabel::OBAtomAtomIter result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBAtomAtomIter((const OpenBabel::OBAtomAtomIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (OpenBabel::OBAtom *) &((OpenBabel::OBAtomAtomIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomBondIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtomBondIter *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  result = (OpenBabel::OBAtomBondIter *)new OpenBabel::OBAtomBondIter(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomBondIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = 0 ; OpenBabel::OBAtomBondIter *result = 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtomBondIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtomBondIter *)new OpenBabel::OBAtomBondIter((OpenBabel::OBAtomBondIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAtomBondIter(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)((OpenBabel::OBAtomBondIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtomBondIter *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (OpenBabel::OBAtomBondIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; int arg2 ; OpenBabel::OBAtomBondIter result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBAtomBondIter((const OpenBabel::OBAtomBondIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (OpenBabel::OBBond *) &((OpenBabel::OBAtomBondIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidueIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBResidueIter *)new OpenBabel::OBResidueIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = 0 ; OpenBabel::OBResidueIter *result = 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidueIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBResidueIter *)new OpenBabel::OBResidueIter((OpenBabel::OBResidueIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBResidueIter(void * jarg1) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; bool result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (bool)((OpenBabel::OBResidueIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBResidueIter *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (OpenBabel::OBResidueIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; int arg2 ; OpenBabel::OBResidueIter result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBResidueIter((const OpenBabel::OBResidueIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (OpenBabel::OBResidue *) &((OpenBabel::OBResidueIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueAtomIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; OpenBabel::OBResidueAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBResidue *)jarg1;  result = (OpenBabel::OBResidueAtomIter *)new OpenBabel::OBResidueAtomIter(arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueAtomIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = 0 ; OpenBabel::OBResidueAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidueAtomIter const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBResidueAtomIter *)new OpenBabel::OBResidueAtomIter((OpenBabel::OBResidueAtomIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBResidueAtomIter(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)((OpenBabel::OBResidueAtomIter const *)arg1)->operator bool();
  jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_obAdvance__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBResidueAtomIter *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (OpenBabel::OBResidueAtomIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_obAdvance__SWIG_1(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ; OpenBabel::OBResidueAtomIter result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (arg1)->operator ++(arg2);
  jresult = new OpenBabel::OBResidueAtomIter((const OpenBabel::OBResidueAtomIter &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  result = (OpenBabel::OBAtom *) &((OpenBabel::OBResidueAtomIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAngleIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolAngleIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolAngleIter *)new OpenBabel::OBMolAngleIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAngleIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAngleIter *arg1 = 0 ; OpenBabel::OBMolAngleIter *result = 0 ; arg1 = (OpenBabel::OBMolAngleIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolAngleIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMolAngleIter *)new OpenBabel::OBMolAngleIter((OpenBabel::OBMolAngleIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolAngleIter(void * jarg1) {
  OpenBabel::OBMolAngleIter *arg1 = (OpenBabel::OBMolAngleIter *) 0 ; arg1 = (OpenBabel::OBMolAngleIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAngleIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAngleIter *arg1 = (OpenBabel::OBMolAngleIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAngleIter *)jarg1; 
  result = (bool)((OpenBabel::OBMolAngleIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAngleIter_obAdvance(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAngleIter *arg1 = (OpenBabel::OBMolAngleIter *) 0 ; OpenBabel::OBMolAngleIter *result = 0 ;
  arg1 = (OpenBabel::OBMolAngleIter *)jarg1;  result = (OpenBabel::OBMolAngleIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAngleIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAngleIter *arg1 = (OpenBabel::OBMolAngleIter *) 0 ; std::vector< unsigned int > result;
  arg1 = (OpenBabel::OBMolAngleIter *)jarg1;  result = ((OpenBabel::OBMolAngleIter const *)arg1)->operator *();
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolTorsionIter__SWIG_0() { void * jresult ; OpenBabel::OBMolTorsionIter *result = 0 ;
  result = (OpenBabel::OBMolTorsionIter *)new OpenBabel::OBMolTorsionIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolTorsionIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolTorsionIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolTorsionIter *)new OpenBabel::OBMolTorsionIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolTorsionIter__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBMolTorsionIter *arg1 = 0 ; OpenBabel::OBMolTorsionIter *result = 0 ; arg1 = (OpenBabel::OBMolTorsionIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolTorsionIter const & type is null", 0);
    return 0; }  
  result = (OpenBabel::OBMolTorsionIter *)new OpenBabel::OBMolTorsionIter((OpenBabel::OBMolTorsionIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolTorsionIter(void * jarg1) {
  OpenBabel::OBMolTorsionIter *arg1 = (OpenBabel::OBMolTorsionIter *) 0 ; arg1 = (OpenBabel::OBMolTorsionIter *)jarg1; 
  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolTorsionIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolTorsionIter *arg1 = (OpenBabel::OBMolTorsionIter *) 0 ; std::vector< unsigned int > result;
  arg1 = (OpenBabel::OBMolTorsionIter *)jarg1;  result = ((OpenBabel::OBMolTorsionIter const *)arg1)->operator *();
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolPairIter__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolPairIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolPairIter *)new OpenBabel::OBMolPairIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolPairIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMolPairIter *arg1 = 0 ; OpenBabel::OBMolPairIter *result = 0 ; arg1 = (OpenBabel::OBMolPairIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolPairIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMolPairIter *)new OpenBabel::OBMolPairIter((OpenBabel::OBMolPairIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolPairIter(void * jarg1) {
  OpenBabel::OBMolPairIter *arg1 = (OpenBabel::OBMolPairIter *) 0 ; arg1 = (OpenBabel::OBMolPairIter *)jarg1;  delete arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolPairIter_obHasNext(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolPairIter *arg1 = (OpenBabel::OBMolPairIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolPairIter *)jarg1; 
  result = (bool)((OpenBabel::OBMolPairIter const *)arg1)->operator bool(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolPairIter_obAdvance(void * jarg1) { void * jresult ;
  OpenBabel::OBMolPairIter *arg1 = (OpenBabel::OBMolPairIter *) 0 ; OpenBabel::OBMolPairIter *result = 0 ;
  arg1 = (OpenBabel::OBMolPairIter *)jarg1;  result = (OpenBabel::OBMolPairIter *) &(arg1)->operator ++();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolPairIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolPairIter *arg1 = (OpenBabel::OBMolPairIter *) 0 ; std::vector< unsigned int > result;
  arg1 = (OpenBabel::OBMolPairIter *)jarg1;  result = ((OpenBabel::OBMolPairIter const *)arg1)->operator *();
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolRingIter__SWIG_0() { void * jresult ; OpenBabel::OBMolRingIter *result = 0 ;
  result = (OpenBabel::OBMolRingIter *)new OpenBabel::OBMolRingIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolRingIter__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBMolRingIter *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  result = (OpenBabel::OBMolRingIter *)new OpenBabel::OBMolRingIter(arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolRingIter__SWIG_2(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = 0 ; OpenBabel::OBMolRingIter *result = 0 ; arg1 = (OpenBabel::OBMolRingIter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMolRingIter const & type is null", 0);
    return 0; }   result = (OpenBabel::OBMolRingIter *)new OpenBabel::OBMolRingIter((OpenBabel::OBMolRingIter const &)*arg1);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBMolRingIter(void * jarg1) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; arg1 = (OpenBabel::OBMolRingIter *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolRingIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBRing *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1; 
  result = (OpenBabel::OBRing *) &((OpenBabel::OBMolRingIter const *)arg1)->operator *(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBElementTable_SWIGUpcast(OpenBabel::OBElementTable *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBIsotopeTable_SWIGUpcast(OpenBabel::OBIsotopeTable *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBTypeTable_SWIGUpcast(OpenBabel::OBTypeTable *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBResidueData_SWIGUpcast(OpenBabel::OBResidueData *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBCommentData_SWIGUpcast(OpenBabel::OBCommentData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBExternalBondData_SWIGUpcast(OpenBabel::OBExternalBondData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBPairData_SWIGUpcast(OpenBabel::OBPairData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSetData_SWIGUpcast(OpenBabel::OBSetData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVirtualBond_SWIGUpcast(OpenBabel::OBVirtualBond *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBRingData_SWIGUpcast(OpenBabel::OBRingData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBUnitCell_SWIGUpcast(OpenBabel::OBUnitCell *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBConformerData_SWIGUpcast(OpenBabel::OBConformerData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSymmetryData_SWIGUpcast(OpenBabel::OBSymmetryData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBTorsionData_SWIGUpcast(OpenBabel::OBTorsionData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBAngleData_SWIGUpcast(OpenBabel::OBAngleData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBChiralData_SWIGUpcast(OpenBabel::OBChiralData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSerialNums_SWIGUpcast(OpenBabel::OBSerialNums *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVibrationData_SWIGUpcast(OpenBabel::OBVibrationData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBDOSData_SWIGUpcast(OpenBabel::OBDOSData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBOrbitalData_SWIGUpcast(OpenBabel::OBOrbitalData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBElectronicTransitionData_SWIGUpcast(OpenBabel::OBElectronicTransitionData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBRotationData_SWIGUpcast(OpenBabel::OBRotationData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVectorData_SWIGUpcast(OpenBabel::OBVectorData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBMatrixData_SWIGUpcast(OpenBabel::OBMatrixData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBGridData_SWIGUpcast(OpenBabel::OBGridData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBAtomTyper_SWIGUpcast(OpenBabel::OBAtomTyper *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBRingTyper_SWIGUpcast(OpenBabel::OBRingTyper *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBFormat_SWIGUpcast(OpenBabel::OBFormat *jarg1) {
    return (OpenBabel::OBPlugin *)jarg1;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBResidue_SWIGUpcast(OpenBabel::OBResidue *jarg1) {
    return (OpenBabel::OBBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBAtom_SWIGUpcast(OpenBabel::OBAtom *jarg1) {
    return (OpenBabel::OBBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBBond_SWIGUpcast(OpenBabel::OBBond *jarg1) {
    return (OpenBabel::OBBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBMol_SWIGUpcast(OpenBabel::OBMol *jarg1) {
    return (OpenBabel::OBBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_AliasData_SWIGUpcast(OpenBabel::AliasData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBAtomClassData_SWIGUpcast(OpenBabel::OBAtomClassData *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBFingerprint_SWIGUpcast(OpenBabel::OBFingerprint *jarg1) {
    return (OpenBabel::OBPlugin *)jarg1;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBDescriptor_SWIGUpcast(OpenBabel::OBDescriptor *jarg1) {
    return (OpenBabel::OBPlugin *)jarg1;
}

SWIGEXPORT OpenBabel::OBFFCalculation2 * SWIGSTDCALL CSharp_OBFFCalculation3_SWIGUpcast(OpenBabel::OBFFCalculation3 *jarg1) {
    return (OpenBabel::OBFFCalculation2 *)jarg1;
}

SWIGEXPORT OpenBabel::OBFFCalculation3 * SWIGSTDCALL CSharp_OBFFCalculation4_SWIGUpcast(OpenBabel::OBFFCalculation4 *jarg1) {
    return (OpenBabel::OBFFCalculation3 *)jarg1;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBForceField_SWIGUpcast(OpenBabel::OBForceField *jarg1) {
    return (OpenBabel::OBPlugin *)jarg1;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBOp_SWIGUpcast(OpenBabel::OBOp *jarg1) {
    return (OpenBabel::OBPlugin *)jarg1;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBRotorRules_SWIGUpcast(OpenBabel::OBRotorRules *jarg1) {
    return (OpenBabel::OBGlobalDataBase *)jarg1;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBRotamerList_SWIGUpcast(OpenBabel::OBRotamerList *jarg1) {
    return (OpenBabel::OBGenericData *)jarg1;
}

#ifdef __cplusplus
}
#endif

