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


#ifdef __cplusplus
template<typename T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};

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_openbabel(
                                                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_openbabel(
                                                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_openbabel(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


// 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/op.h>

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



#include <stdexcept>


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


#include <string>

SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_1(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,std::vector< int >::value_type 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,std::vector< int >::value_type 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(std::vector< int >::value_type 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,std::vector< int >::value_type const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,std::vector< int >::value_type 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,std::vector< int >::value_type 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 void std_vector_Sl_int_Sg__Remove(std::vector< int > *self,std::vector< int >::value_type const &value){
        std::vector<int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          self->erase(it);
      }
SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_1(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,std::vector< unsigned int >::value_type 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,std::vector< unsigned int >::value_type 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(std::vector< unsigned int >::value_type 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,std::vector< unsigned int >::value_type 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,std::vector< unsigned int >::value_type 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,std::vector< unsigned int >::value_type 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 void std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,std::vector< unsigned int >::value_type const &value){
        std::vector<unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          self->erase(it);
      }
SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_1(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,std::vector< double >::value_type 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,std::vector< double >::value_type 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(std::vector< double >::value_type 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,std::vector< double >::value_type const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,std::vector< double >::value_type 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,std::vector< double >::value_type 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 void std_vector_Sl_double_Sg__Remove(std::vector< double > *self,std::vector< double >::value_type const &value){
        std::vector<double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          self->erase(it);
      }
SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_1(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::vector< std::string >::value_type 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::vector< std::string >::value_type 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::vector< std::string >::value_type 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::vector< std::string >::value_type 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::vector< std::string >::value_type 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::vector< std::string >::value_type 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 void std_vector_Sl_std_string_Sg__Remove(std::vector< std::string > *self,std::vector< std::string >::value_type const &value){
        std::vector<std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          self->erase(it);
      }
SWIGINTERN std::vector< OpenBabel::vector3 > *new_std_vector_Sl_OpenBabel_vector3_Sg___SWIG_1(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,std::vector< OpenBabel::vector3 >::value_type 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,std::vector< OpenBabel::vector3 >::value_type 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(std::vector< OpenBabel::vector3 >::value_type 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< OpenBabel::OBMol > *new_std_vector_Sl_OpenBabel_OBMol_Sg___SWIG_1(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,std::vector< OpenBabel::OBMol >::value_type 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,std::vector< OpenBabel::OBMol >::value_type 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(std::vector< OpenBabel::OBMol >::value_type 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_1(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,std::vector< OpenBabel::OBBond >::value_type 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,std::vector< OpenBabel::OBBond >::value_type 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(std::vector< OpenBabel::OBBond >::value_type 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_1(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,std::vector< OpenBabel::OBResidue >::value_type 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,std::vector< OpenBabel::OBResidue >::value_type 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(std::vector< OpenBabel::OBResidue >::value_type 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_1(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,std::vector< OpenBabel::OBRing >::value_type 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,std::vector< OpenBabel::OBRing >::value_type 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(std::vector< OpenBabel::OBRing >::value_type 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::OBRing * > *new_std_vector_Sl_OpenBabel_OBRing_Sm__Sg___SWIG_1(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,std::vector< OpenBabel::OBRing * >::value_type 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,std::vector< OpenBabel::OBRing * >::value_type 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(std::vector< OpenBabel::OBRing * >::value_type 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 std::vector< OpenBabel::OBGenericData * > *new_std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg___SWIG_1(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,std::vector< OpenBabel::OBGenericData * >::value_type 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,std::vector< OpenBabel::OBGenericData * >::value_type 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(std::vector< OpenBabel::OBGenericData * >::value_type 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);
      }

#ifdef __cplusplus
extern "C" {
#endif

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 ; std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ; arg1 = (std::vector< int > *)jarg1;  temp2 = (std::vector< int >::value_type)jarg2; 
  arg2 = &temp2;  (arg1)->push_back((std::vector< int >::value_type 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(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_1(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 ; std::vector< int >::value_type *result = 0 ;
  arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2;  try { {
      std::vector< int >::const_reference _result_ref = std_vector_Sl_int_Sg__getitem(arg1,arg2);
      result = (std::vector< int >::value_type *) &_result_ref; } }  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 ; std::vector< int >::value_type *arg3 = 0 ;
  std::vector< int >::value_type temp3 ; arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< int >::value_type)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 ; std::vector< int >::value_type *arg3 = 0 ;
  std::vector< int >::value_type temp3 ; arg1 = (std::vector< int > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< int >::value_type)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 ;
  std::vector< int >::value_type *arg1 = 0 ; int arg2 ; std::vector< int >::value_type temp1 ; std::vector< int > *result = 0 ;
  temp1 = (std::vector< int >::value_type)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 ; std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ; bool result; arg1 = (std::vector< int > *)jarg1; 
  temp2 = (std::vector< int >::value_type)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 ; std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ; int result; arg1 = (std::vector< int > *)jarg1; 
  temp2 = (std::vector< int >::value_type)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 ; std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ; int result; arg1 = (std::vector< int > *)jarg1; 
  temp2 = (std::vector< int >::value_type)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vectorInt_Remove(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ; std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ; arg1 = (std::vector< int > *)jarg1;  temp2 = (std::vector< int >::value_type)jarg2; 
  arg2 = &temp2;  std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2); }
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_vectorUnsignedInt_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_vectorUnsignedInt_Add(void * jarg1, unsigned int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::value_type *arg2 = 0 ;
  std::vector< unsigned int >::value_type temp2 ; arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (std::vector< unsigned int >::value_type)jarg2;  arg2 = &temp2; 
  (arg1)->push_back((std::vector< unsigned int >::value_type const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt__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_vectorUnsignedInt__SWIG_1(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_1(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_vectorUnsignedInt_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_vectorUnsignedInt_getitem(void * jarg1, int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ;
  std::vector< unsigned int >::value_type *result = 0 ; arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  try {
    { std::vector< unsigned int >::const_reference _result_ref = std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
      result = (std::vector< unsigned int >::value_type *) &_result_ref; } }  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = *result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vectorUnsignedInt_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ; std::vector< unsigned int >::value_type temp3 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (std::vector< unsigned int >::value_type)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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; int arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ; std::vector< unsigned int >::value_type temp3 ;
  arg1 = (std::vector< unsigned int > *)jarg1;  arg2 = (int)jarg2;  temp3 = (std::vector< unsigned int >::value_type)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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_Repeat(unsigned int jarg1, int jarg2) { void * jresult ;
  std::vector< unsigned int >::value_type *arg1 = 0 ; int arg2 ; std::vector< unsigned int >::value_type temp1 ;
  std::vector< unsigned int > *result = 0 ; temp1 = (std::vector< unsigned int >::value_type)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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_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_vectorUnsignedInt_Contains(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::value_type *arg2 = 0 ;
  std::vector< unsigned int >::value_type temp2 ; bool result; arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (std::vector< unsigned int >::value_type)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_vectorUnsignedInt_IndexOf(void * jarg1, unsigned int jarg2) { int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::value_type *arg2 = 0 ;
  std::vector< unsigned int >::value_type temp2 ; int result; arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (std::vector< unsigned int >::value_type)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_vectorUnsignedInt_LastIndexOf(void * jarg1, unsigned int jarg2) { int jresult ;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::value_type *arg2 = 0 ;
  std::vector< unsigned int >::value_type temp2 ; int result; arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (std::vector< unsigned int >::value_type)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vectorUnsignedInt_Remove(void * jarg1, unsigned int jarg2) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; std::vector< unsigned int >::value_type *arg2 = 0 ;
  std::vector< unsigned int >::value_type temp2 ; arg1 = (std::vector< unsigned int > *)jarg1; 
  temp2 = (std::vector< unsigned int >::value_type)jarg2;  arg2 = &temp2; 
  std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_vectorUnsignedInt(void * jarg1) {
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; arg1 = (std::vector< unsigned int > *)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 ; std::vector< double >::value_type *arg2 = 0 ;
  std::vector< double >::value_type temp2 ; arg1 = (std::vector< double > *)jarg1; 
  temp2 = (std::vector< double >::value_type)jarg2;  arg2 = &temp2; 
  (arg1)->push_back((std::vector< double >::value_type 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(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_1(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 ; std::vector< double >::value_type *result = 0 ;
  arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2;  try { {
      std::vector< double >::const_reference _result_ref = std_vector_Sl_double_Sg__getitem(arg1,arg2);
      result = (std::vector< double >::value_type *) &_result_ref; } }  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 ; std::vector< double >::value_type *arg3 = 0 ;
  std::vector< double >::value_type temp3 ; arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< double >::value_type)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 ; std::vector< double >::value_type *arg3 = 0 ;
  std::vector< double >::value_type temp3 ; arg1 = (std::vector< double > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< double >::value_type)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 ;
  std::vector< double >::value_type *arg1 = 0 ; int arg2 ; std::vector< double >::value_type temp1 ;
  std::vector< double > *result = 0 ; temp1 = (std::vector< double >::value_type)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 ; std::vector< double >::value_type *arg2 = 0 ;
  std::vector< double >::value_type temp2 ; bool result; arg1 = (std::vector< double > *)jarg1; 
  temp2 = (std::vector< double >::value_type)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 ; std::vector< double >::value_type *arg2 = 0 ;
  std::vector< double >::value_type temp2 ; int result; arg1 = (std::vector< double > *)jarg1; 
  temp2 = (std::vector< double >::value_type)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 ; std::vector< double >::value_type *arg2 = 0 ;
  std::vector< double >::value_type temp2 ; int result; arg1 = (std::vector< double > *)jarg1; 
  temp2 = (std::vector< double >::value_type)jarg2;  arg2 = &temp2; 
  result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vectorDouble_Remove(void * jarg1, double jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ; std::vector< double >::value_type *arg2 = 0 ;
  std::vector< double >::value_type temp2 ; arg1 = (std::vector< double > *)jarg1; 
  temp2 = (std::vector< double >::value_type)jarg2;  arg2 = &temp2; 
  std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2); }
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_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::vector< std::string >::value_type *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::vector< std::string >::value_type 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(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_1(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::vector< std::string >::value_type *result = 0 ; arg1 = (std::vector< std::string > *)jarg1;  arg2 = (int)jarg2;  try { {
      std::vector< std::string >::const_reference _result_ref = std_vector_Sl_std_string_Sg__getitem(arg1,arg2);
      result = (std::vector< std::string >::value_type *) &_result_ref; } }  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::vector< std::string >::value_type *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::vector< std::string >::value_type *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::vector< std::string >::value_type *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::vector< std::string >::value_type *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::vector< std::string >::value_type *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::vector< std::string >::value_type *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 void SWIGSTDCALL CSharp_vectorString_Remove(void * jarg1, char * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::vector< std::string >::value_type *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;  std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2); }
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_vVector3_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_vVector3_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  std::vector< OpenBabel::vector3 >::value_type *arg2 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (std::vector< OpenBabel::vector3 >::value_type *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 >::value_type const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::vector3 >::value_type const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vVector3_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_vVector3_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_vVector3_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_vVector3__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_vVector3__SWIG_1(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_1(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_vVector3_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_vVector3_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::vector3 >::const_reference _result_ref = std_vector_Sl_OpenBabel_vector3_Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::vector3 >::value_type *) &_result_ref; } }  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vVector3_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::vector3 >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 >::value_type 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_vVector3_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_vVector3_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_vVector3_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ; int arg2 ;
  std::vector< OpenBabel::vector3 >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::vector3 > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::vector3 >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 >::value_type 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_vVector3_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_vVector3_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_vVector3_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_vVector3_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::vector3 >::value_type *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::vector3 > *result = 0 ;
  arg1 = (std::vector< OpenBabel::vector3 >::value_type *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::vector3 >::value_type 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_vVector3_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_vVector3_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_vVector3_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_vVector3(void * jarg1) {
  std::vector< OpenBabel::vector3 > *arg1 = (std::vector< OpenBabel::vector3 > *) 0 ;
  arg1 = (std::vector< OpenBabel::vector3 > *)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 ;
  std::vector< OpenBabel::OBMol >::value_type *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBMol >::value_type *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol >::value_type const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::OBMol >::value_type 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(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_1(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 ;
  std::vector< OpenBabel::OBMol >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBMol >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBMol_Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBMol >::value_type *) &_result_ref; } }  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 ;
  std::vector< OpenBabel::OBMol >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBMol >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol >::value_type 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 ;
  std::vector< OpenBabel::OBMol >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBMol > *)jarg1;  arg2 = (int)jarg2; 
  arg3 = (std::vector< OpenBabel::OBMol >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol >::value_type 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 ;
  std::vector< OpenBabel::OBMol >::value_type *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBMol > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBMol >::value_type *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBMol >::value_type 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 ;
  std::vector< OpenBabel::OBBond >::value_type *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBBond >::value_type *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond >::value_type const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::OBBond >::value_type 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(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_1(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 ;
  std::vector< OpenBabel::OBBond >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBBond >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBBond_Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBBond >::value_type *) &_result_ref; } }  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 ;
  std::vector< OpenBabel::OBBond >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBBond >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond >::value_type 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 ;
  std::vector< OpenBabel::OBBond >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBBond > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBBond >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond >::value_type 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 ;
  std::vector< OpenBabel::OBBond >::value_type *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBBond > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBBond >::value_type *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBBond >::value_type 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 ;
  std::vector< OpenBabel::OBResidue >::value_type *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBResidue >::value_type *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue >::value_type const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::OBResidue >::value_type 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(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_1(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 ;
  std::vector< OpenBabel::OBResidue >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBResidue >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBResidue_Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBResidue >::value_type *) &_result_ref; } }  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 ;
  std::vector< OpenBabel::OBResidue >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBResidue >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue >::value_type 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 ;
  std::vector< OpenBabel::OBResidue >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBResidue > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBResidue >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue >::value_type 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 ;
  std::vector< OpenBabel::OBResidue >::value_type *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBResidue > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBResidue >::value_type *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBResidue >::value_type 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 ;
  std::vector< OpenBabel::OBRing >::value_type *arg2 = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing >::value_type *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing >::value_type const & type is null", 0);
    return ; }   (arg1)->push_back((std::vector< OpenBabel::OBRing >::value_type 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(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_1(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 ;
  std::vector< OpenBabel::OBRing >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBRing >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBRing_Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBRing >::value_type *) &_result_ref; } }  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 ;
  std::vector< OpenBabel::OBRing >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBRing >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing >::value_type 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 ;
  std::vector< OpenBabel::OBRing >::value_type *arg3 = 0 ; arg1 = (std::vector< OpenBabel::OBRing > *)jarg1; 
  arg2 = (int)jarg2;  arg3 = (std::vector< OpenBabel::OBRing >::value_type *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing >::value_type 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 ;
  std::vector< OpenBabel::OBRing >::value_type *arg1 = 0 ; int arg2 ; std::vector< OpenBabel::OBRing > *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing >::value_type *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing >::value_type 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_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 ;
  std::vector< OpenBabel::OBRing * >::value_type *arg2 = 0 ; std::vector< OpenBabel::OBRing * >::value_type temp2 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  temp2 = (std::vector< OpenBabel::OBRing * >::value_type)jarg2;
  arg2 = &temp2;  (arg1)->push_back((std::vector< OpenBabel::OBRing * >::value_type 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(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_1(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 ;
  std::vector< OpenBabel::OBRing * >::value_type *result = 0 ; arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1; 
  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBRing * >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBRing_Sm__Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBRing * >::value_type *) &_result_ref; } }  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 ;
  std::vector< OpenBabel::OBRing * >::value_type *arg3 = 0 ; std::vector< OpenBabel::OBRing * >::value_type temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< OpenBabel::OBRing * >::value_type)jarg3; arg3 = &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 ;
  std::vector< OpenBabel::OBRing * >::value_type *arg3 = 0 ; std::vector< OpenBabel::OBRing * >::value_type temp3 = 0 ;
  arg1 = (std::vector< OpenBabel::OBRing * > *)jarg1;  arg2 = (int)jarg2; 
  temp3 = (std::vector< OpenBabel::OBRing * >::value_type)jarg3; arg3 = &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 ;
  std::vector< OpenBabel::OBRing * >::value_type *arg1 = 0 ; int arg2 ;
  std::vector< OpenBabel::OBRing * >::value_type temp1 = 0 ; std::vector< OpenBabel::OBRing * > *result = 0 ;
  temp1 = (std::vector< OpenBabel::OBRing * >::value_type)jarg1; arg1 = &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 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_vectorData_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_vectorData_Add(void * jarg1, void * jarg2) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  std::vector< OpenBabel::OBGenericData * >::value_type *arg2 = 0 ;
  std::vector< OpenBabel::OBGenericData * >::value_type temp2 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  temp2 = (std::vector< OpenBabel::OBGenericData * >::value_type)jarg2; arg2 = &temp2; 
  (arg1)->push_back((std::vector< OpenBabel::OBGenericData * >::value_type const &)*arg2); }
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vectorData_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_vectorData_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_vectorData_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_vectorData__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_vectorData__SWIG_1(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_1(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_vectorData_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_vectorData_getitem(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * >::value_type *result = 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1;  arg2 = (int)jarg2;  try { {
      std::vector< OpenBabel::OBGenericData * >::const_reference _result_ref = std_vector_Sl_OpenBabel_OBGenericData_Sm__Sg__getitem(arg1,arg2);
      result = (std::vector< OpenBabel::OBGenericData * >::value_type *) &_result_ref; } }  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); return 0; } 
  jresult = (void *)*result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_vectorData_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * >::value_type *arg3 = 0 ;
  std::vector< OpenBabel::OBGenericData * >::value_type temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (std::vector< OpenBabel::OBGenericData * >::value_type)jarg3; arg3 = &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_vectorData_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_vectorData_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_vectorData_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * >::value_type *arg3 = 0 ;
  std::vector< OpenBabel::OBGenericData * >::value_type temp3 = 0 ; arg1 = (std::vector< OpenBabel::OBGenericData * > *)jarg1; 
  arg2 = (int)jarg2;  temp3 = (std::vector< OpenBabel::OBGenericData * >::value_type)jarg3; arg3 = &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_vectorData_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_vectorData_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_vectorData_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_vectorData_Repeat(void * jarg1, int jarg2) { void * jresult ;
  std::vector< OpenBabel::OBGenericData * >::value_type *arg1 = 0 ; int arg2 ;
  std::vector< OpenBabel::OBGenericData * >::value_type temp1 = 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  temp1 = (std::vector< OpenBabel::OBGenericData * >::value_type)jarg1; arg1 = &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_vectorData_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_vectorData_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_vectorData_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 void SWIGSTDCALL CSharp_delete_vectorData(void * jarg1) {
  std::vector< OpenBabel::OBGenericData * > *arg1 = (std::vector< OpenBabel::OBGenericData * > *) 0 ;
  arg1 = (std::vector< OpenBabel::OBGenericData * > *)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 int SWIGSTDCALL CSharp_OBGlobalDataBase_GetSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBGlobalDataBase *arg1 = (OpenBabel::OBGlobalDataBase *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBGlobalDataBase *)jarg1;  result = (unsigned int)(arg1)->GetSize(); jresult = 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 unsigned int SWIGSTDCALL CSharp_OBTypeTable_Translate__SWIG_1(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ; OpenBabel::OBTypeTable *arg1 = (OpenBabel::OBTypeTable *) 0 ; std::string *arg2 = 0 ;
  std::string *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBTypeTable *)jarg1;  arg2 = (std::string *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return 0; }  
  if (!jarg3) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return 0; } 
  std::string arg3_str(jarg3); arg3 = &arg3_str;  result = (bool)(arg1)->Translate(*arg2,(std::string const &)*arg3);
  jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBTypeTable_Translate__SWIG_2(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_DoubleType_hi_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::DoubleType *)jarg1; 
  arg2 = (unsigned int)jarg2;  if (arg1) (arg1)->hi = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DoubleType_hi_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int result; arg1 = (OpenBabel::DoubleType *)jarg1; 
  result = (unsigned int) ((arg1)->hi); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_DoubleType_lo_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::DoubleType *)jarg1; 
  arg2 = (unsigned int)jarg2;  if (arg1) (arg1)->lo = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DoubleType_lo_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int result; arg1 = (OpenBabel::DoubleType *)jarg1; 
  result = (unsigned int) ((arg1)->lo); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_DoubleType() { void * jresult ; OpenBabel::DoubleType *result = 0 ;
  result = (OpenBabel::DoubleType *)new OpenBabel::DoubleType(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_DoubleType(void * jarg1) { OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ;
  arg1 = (OpenBabel::DoubleType *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_DoubleMultiply(unsigned int jarg1, unsigned int jarg2, void * jarg3) { unsigned int arg1 ;
  unsigned int arg2 ; OpenBabel::DoubleType *arg3 = (OpenBabel::DoubleType *) 0 ; arg1 = (unsigned int)jarg1; 
  arg2 = (unsigned int)jarg2;  arg3 = (OpenBabel::DoubleType *)jarg3;  OpenBabel::DoubleMultiply(arg1,arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_DoubleAdd(void * jarg1, unsigned int jarg2) {
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int arg2 ; arg1 = (OpenBabel::DoubleType *)jarg1; 
  arg2 = (unsigned int)jarg2;  OpenBabel::DoubleAdd(arg1,arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DoubleModulus(void * jarg1, unsigned int jarg2) { unsigned int jresult ;
  OpenBabel::DoubleType *arg1 = (OpenBabel::DoubleType *) 0 ; unsigned int arg2 ; unsigned int result;
  arg1 = (OpenBabel::DoubleType *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (unsigned int)OpenBabel::DoubleModulus(arg1,arg2); jresult = result;  return jresult; }
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 double SWIGSTDCALL CSharp_M_PI_get() { double jresult ; double result; result = (double) 3.14159265358979323846;
  jresult = result;  return jresult; }
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 double SWIGSTDCALL CSharp_RAD_TO_DEG_get() { double jresult ; double result;
  result = (double) (180.0/3.14159265358979323846); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_DEG_TO_RAD_get() { double jresult ; double result;
  result = (double) (3.14159265358979323846/180.0); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector3__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_vector3__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_vector3__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_vector3__SWIG_3() { void * jresult ; OpenBabel::vector3 *result = 0 ;
  result = (OpenBabel::vector3 *)new OpenBabel::vector3(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector3__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_vector3__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_vector3(void * jarg1) { OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ;
  arg1 = (OpenBabel::vector3 *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_vector3_Set__SWIG_0(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_vector3_Set__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *arg2 = (double *) 0 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double *)jarg2;  (arg1)->Set((double const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_vector3_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_vector3_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_vector3_SetZ(void * jarg1, double jarg2) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double arg2 ; arg1 = (OpenBabel::vector3 *)jarg1; 
  arg2 = (double)jarg2;  (arg1)->SetZ(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_vector3_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_vector3_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_vector3_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_vector3_randomUnitVector__SWIG_1(void * jarg1) {
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  (arg1)->randomUnitVector(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_vector3_normalize(void * jarg1) { void * jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; OpenBabel::vector3 *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  {
    OpenBabel::vector3 &_result_ref = (arg1)->normalize(); result = (OpenBabel::vector3 *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector3_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_vector3_length_2(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_vector3_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_vector3_x__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  {
    double const &_result_ref = ((OpenBabel::vector3 const *)arg1)->x(); result = (double *) &_result_ref; } 
  jresult = *result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_vector3_y__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  {
    double const &_result_ref = ((OpenBabel::vector3 const *)arg1)->y(); result = (double *) &_result_ref; } 
  jresult = *result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_vector3_z__SWIG_0(void * jarg1) { double jresult ;
  OpenBabel::vector3 *arg1 = (OpenBabel::vector3 *) 0 ; double *result = 0 ; arg1 = (OpenBabel::vector3 *)jarg1;  {
    double const &_result_ref = ((OpenBabel::vector3 const *)arg1)->z(); result = (double *) &_result_ref; } 
  jresult = *result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector3_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_vector3_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_vector3_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_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 void * SWIGSTDCALL CSharp_VZero_get() { void * jresult ; OpenBabel::vector3 *result = 0 ; {
    OpenBabel::vector3 const &_result_ref = OpenBabel::VZero; result = (OpenBabel::vector3 *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VX_get() { void * jresult ; OpenBabel::vector3 *result = 0 ; {
    OpenBabel::vector3 const &_result_ref = OpenBabel::VX; result = (OpenBabel::vector3 *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VY_get() { void * jresult ; OpenBabel::vector3 *result = 0 ; {
    OpenBabel::vector3 const &_result_ref = OpenBabel::VY; result = (OpenBabel::vector3 *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_VZ_get() { void * jresult ; OpenBabel::vector3 *result = 0 ; {
    OpenBabel::vector3 const &_result_ref = OpenBabel::VZ; result = (OpenBabel::vector3 *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_matrix3x3__SWIG_0() { void * jresult ; OpenBabel::matrix3x3 *result = 0 ;
  result = (OpenBabel::matrix3x3 *)new OpenBabel::matrix3x3(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_matrix3x3__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_matrix3x3__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_new_matrix3x3__SWIG_3(void * jarg1) { void * jresult ; double (*arg1)[3] ;
  OpenBabel::matrix3x3 *result = 0 ; arg1 = (double (*)[3])jarg1; 
  result = (OpenBabel::matrix3x3 *)new OpenBabel::matrix3x3((double (*)[3])arg1); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_matrix3x3(void * jarg1) { OpenBabel::matrix3x3 *arg1 = (OpenBabel::matrix3x3 *) 0 ;
  arg1 = (OpenBabel::matrix3x3 *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_matrix3x3_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_transform3d__SWIG_0() { void * jresult ; OpenBabel::transform3d *result = 0 ;
  result = (OpenBabel::transform3d *)new OpenBabel::transform3d(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_transform3d__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_transform3d__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_transform3d__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 void * SWIGSTDCALL CSharp_new_transform3d__SWIG_4(void * jarg1, void * jarg2) { void * jresult ; double (*arg1)[3] ;
  double *arg2 ; OpenBabel::transform3d *result = 0 ; arg1 = (double (*)[3])jarg1;  arg2 = (double *)jarg2; 
  result = (OpenBabel::transform3d *)new OpenBabel::transform3d((double (*)[3])arg1,arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_transform3d_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_transform3d_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_transform3d_Normalize(void * jarg1) {
  OpenBabel::transform3d *arg1 = (OpenBabel::transform3d *) 0 ; arg1 = (OpenBabel::transform3d *)jarg1;  (arg1)->Normalize(); }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_transform3d(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; 
  { std::string const &_result_ref = ((OpenBabel::SpaceGroup const *)arg1)->GetHMName(); result = (std::string *) &_result_ref; }
   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; 
  { std::string const &_result_ref = ((OpenBabel::SpaceGroup const *)arg1)->GetHallName();
    result = (std::string *) &_result_ref; }  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_Transform(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  SwigValueWrapper< std::list< OpenBabel::vector3 > > result; arg1 = (OpenBabel::SpaceGroup *)jarg1; 
  arg2 = (OpenBabel::vector3 *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return 0; }   result = ((OpenBabel::SpaceGroup const *)arg1)->Transform((OpenBabel::vector3 const &)*arg2);
  jresult = new std::list< OpenBabel::vector3 >((const std::list< OpenBabel::vector3 > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_SpaceGroup_BeginTransform(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; OpenBabel::transform3dIterator *arg2 = 0 ;
  OpenBabel::transform3d *result = 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1;  arg2 = (OpenBabel::transform3dIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::transform3dIterator & type is null", 0);
    return 0; }   result = (OpenBabel::transform3d *)((OpenBabel::SpaceGroup const *)arg1)->BeginTransform(*arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_SpaceGroup_NextTransform(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::SpaceGroup *arg1 = (OpenBabel::SpaceGroup *) 0 ; OpenBabel::transform3dIterator *arg2 = 0 ;
  OpenBabel::transform3d *result = 0 ; arg1 = (OpenBabel::SpaceGroup *)jarg1;  arg2 = (OpenBabel::transform3dIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::transform3dIterator & type is null", 0);
    return 0; }   result = (OpenBabel::transform3d *)((OpenBabel::SpaceGroup const *)arg1)->NextTransform(*arg2);
  jresult = (void *)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 int SWIGSTDCALL CSharp_UndefinedData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::UndefinedData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PairData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::PairData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_EnergyData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::EnergyData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CommentData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CommentData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ConformerData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::ConformerData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ExternalBondData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::ExternalBondData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_RotamerList_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::RotamerList; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VirtualBondData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::VirtualBondData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_RingData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::RingData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_TorsionData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::TorsionData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AngleData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::AngleData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SerialNums_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::SerialNums; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_UnitCell_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::UnitCell; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SpinData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::SpinData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ChargeData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::ChargeData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SymmetryData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::SymmetryData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ChiralData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::ChiralData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OccupationData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::OccupationData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_DensityData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::DensityData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ElectronicData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::ElectronicData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VibrationData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::VibrationData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_RotationData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::RotationData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NuclearData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::NuclearData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SetData_get() { int jresult ; int result; result = (int)OpenBabel::OBGenericDataType::SetData;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_GridData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::GridData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VectorData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::VectorData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MatrixData_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::MatrixData; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData0_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData0; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData1_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData1; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData2_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData2; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData3_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData3; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData4_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData4; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData5_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData5; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData6_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData6; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData7_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData7; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData8_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData8; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData9_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData9; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData10_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData10; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData11_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData11; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData12_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData12; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData13_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData13; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData14_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData14; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CustomData15_get() { int jresult ; int result;
  result = (int)OpenBabel::OBGenericDataType::CustomData15; jresult = result;  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_OBGenericData_Clone(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBGenericData *arg1 = (OpenBabel::OBGenericData *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  OpenBabel::OBGenericData *result = 0 ; arg1 = (OpenBabel::OBGenericData *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2; 
  result = (OpenBabel::OBGenericData *)((OpenBabel::OBGenericData const *)arg1)->Clone(arg2); 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;  {
    std::string const &_result_ref = ((OpenBabel::OBGenericData const *)arg1)->GetAttribute();
    result = (std::string *) &_result_ref; }  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;  {
    std::string const &_result_ref = ((OpenBabel::OBGenericData const *)arg1)->GetValue();
    result = (std::string *) &_result_ref; }  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_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 * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  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 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_SetData(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)->SetData(arg2); }
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 int SWIGSTDCALL CSharp_OBBase_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; unsigned int result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = (unsigned int)((OpenBabel::OBBase const *)arg1)->DataSize(); jresult = 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;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  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_OBBase_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = (arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBBase_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBBase *)jarg1; 
  result = (arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)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;  {
    std::string const &_result_ref = ((OpenBabel::OBCommentData const *)arg1)->GetData();
    result = (std::string *) &_result_ref; }  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;  {
    std::vector< OpenBabel::OBGenericData * > const &_result_ref = ((OpenBabel::OBSetData const *)arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSetData_GetBegin(void * jarg1) { void * jresult ;
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBSetData *)jarg1; 
  result = (arg1)->GetBegin();
  jresult = new std::vector< OpenBabel::OBGenericData * >::iterator((const std::vector< OpenBabel::OBGenericData * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSetData_GetEnd(void * jarg1) { void * jresult ;
  OpenBabel::OBSetData *arg1 = (OpenBabel::OBSetData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBSetData *)jarg1; 
  result = (arg1)->GetEnd();
  jresult = new std::vector< OpenBabel::OBGenericData * >::iterator((const std::vector< OpenBabel::OBGenericData * >::iterator &)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;  { std::vector< OpenBabel::OBRing * > &_result_ref = (arg1)->GetData();
    result = (std::vector< OpenBabel::OBRing * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingData_BeginRings(void * jarg1) { void * jresult ;
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBRing * >::iterator > result; arg1 = (OpenBabel::OBRingData *)jarg1; 
  result = (arg1)->BeginRings();
  jresult = new std::vector< OpenBabel::OBRing * >::iterator((const std::vector< OpenBabel::OBRing * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingData_EndRings(void * jarg1) { void * jresult ;
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBRing * >::iterator > result; arg1 = (OpenBabel::OBRingData *)jarg1; 
  result = (arg1)->EndRings();
  jresult = new std::vector< OpenBabel::OBRing * >::iterator((const std::vector< OpenBabel::OBRing * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingData_BeginRing(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ; std::vector< OpenBabel::OBRing * >::iterator *arg2 = 0 ;
  OpenBabel::OBRing *result = 0 ; arg1 = (OpenBabel::OBRingData *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBRing *)(arg1)->BeginRing(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingData_NextRing(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBRingData *arg1 = (OpenBabel::OBRingData *) 0 ; std::vector< OpenBabel::OBRing * >::iterator *arg2 = 0 ;
  OpenBabel::OBRing *result = 0 ; arg1 = (OpenBabel::OBRingData *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBRing * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBRing * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBRing *)(arg1)->NextRing(*arg2); 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_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_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 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 ;
  SwigValueWrapper< 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 ;
  SwigValueWrapper< 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 ;
  SwigValueWrapper< 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 ;
  SwigValueWrapper< 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 ;
  SwigValueWrapper< 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 ;
  SwigValueWrapper< 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__SWIG_0(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_AddTorsion__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  OpenBabel::quad< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBTorsion *)jarg1; 
  arg2 = (OpenBabel::quad< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::quad< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > & type is null", 0);
    return 0; }   result = (bool)(arg1)->AddTorsion(*arg2); 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 int SWIGSTDCALL CSharp_OBTorsion_GetSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ; unsigned int result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = (unsigned int)((OpenBabel::OBTorsion const *)arg1)->GetSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBTorsion_GetBC(void * jarg1) { void * jresult ;
  OpenBabel::OBTorsion *arg1 = (OpenBabel::OBTorsion *) 0 ;
  SwigValueWrapper< std::pair< OpenBabel::OBAtom *,OpenBabel::OBAtom * > > result; arg1 = (OpenBabel::OBTorsion *)jarg1; 
  result = (arg1)->GetBC();
  jresult = new std::pair< OpenBabel::OBAtom *,OpenBabel::OBAtom * >((const std::pair< OpenBabel::OBAtom *,OpenBabel::OBAtom * > &)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 ;
  SwigValueWrapper< 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 int SWIGSTDCALL CSharp_OBTorsionData_GetSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBTorsionData *arg1 = (OpenBabel::OBTorsionData *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBTorsionData *)jarg1;  result = (unsigned int)((OpenBabel::OBTorsionData const *)arg1)->GetSize();
  jresult = 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__SWIG_0(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_OBAngle_SetAtoms__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBAngle *arg1 = (OpenBabel::OBAngle *) 0 ;
  OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBAngle *)jarg1; 
  arg2 = (OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::triple< OpenBabel::OBAtom *,OpenBabel::OBAtom *,OpenBabel::OBAtom * > & type is null", 0);
    return ; }   (arg1)->SetAtoms(*arg2); }
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__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; int **arg2 = (int **) 0 ;
  unsigned int *arg3 = 0 ; unsigned int result; arg1 = (OpenBabel::OBAngleData *)jarg1;  arg2 = (int **)jarg2; 
  arg3 = (unsigned int *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); return 0; }  
  result = (unsigned int)(arg1)->FillAngleArray(arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAngleData_FillAngleArray__SWIG_1(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 int SWIGSTDCALL CSharp_OBAngleData_GetSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAngleData *arg1 = (OpenBabel::OBAngleData *) 0 ; unsigned int result; arg1 = (OpenBabel::OBAngleData *)jarg1; 
  result = (unsigned int)((OpenBabel::OBAngleData const *)arg1)->GetSize(); jresult = 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;  { std::map< int,OpenBabel::OBAtom * > &_result_ref = (arg1)->GetData();
    result = (std::map< int,OpenBabel::OBAtom * > *) &_result_ref; }  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(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_GetLx(void * jarg1) { void * jresult ;
  OpenBabel::OBVibrationData *arg1 = (OpenBabel::OBVibrationData *) 0 ;
  SwigValueWrapper< 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 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_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_GetAxes__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  OpenBabel::OBGridData *arg1 = (OpenBabel::OBGridData *) 0 ; double *arg2 ; double *arg3 ; double *arg4 ;
  arg1 = (OpenBabel::OBGridData *)jarg1;  arg2 = (double *)jarg2;  arg3 = (double *)jarg3;  arg4 = (double *)jarg4; 
  ((OpenBabel::OBGridData const *)arg1)->GetAxes(arg2,arg3,arg4); }
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__SWIG_1(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 int SWIGSTDCALL CSharp_MaxMonoAtom_get() { int jresult ; int result; result = (int) 20; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MaxMonoBond_get() { int jresult ; int result; result = (int) 20; jresult = result; 
  return jresult; }
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_OBAromaticTyper() { void * jresult ; OpenBabel::OBAromaticTyper *result = 0 ;
  result = (OpenBabel::OBAromaticTyper *)new OpenBabel::OBAromaticTyper(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBAromaticTyper(void * jarg1) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; arg1 = (OpenBabel::OBAromaticTyper *)jarg1; 
  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_AssignAromaticFlags(void * jarg1, void * jarg2) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->AssignAromaticFlags(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_PropagatePotentialAromatic(void * jarg1, void * jarg2) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (arg1)->PropagatePotentialAromatic(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_SelectRootAtoms__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ; bool arg3 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = jarg3 ? true : false;  (arg1)->SelectRootAtoms(*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_SelectRootAtoms__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->SelectRootAtoms(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_ExcludeSmallRing(void * jarg1, void * jarg2) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  (arg1)->ExcludeSmallRing(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAromaticTyper_CheckAromaticity(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  int arg3 ; arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (int)jarg3; 
  (arg1)->CheckAromaticity(arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAromaticTyper_TraverseCycle(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  unsigned int jresult ; OpenBabel::OBAromaticTyper *arg1 = (OpenBabel::OBAromaticTyper *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *arg4 = (OpenBabel::OBBond *) 0 ; std::pair< int,int > *arg5 = 0 ; int arg6 ; bool result;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  arg4 = (OpenBabel::OBBond *)jarg4;  arg5 = (std::pair< int,int > *)jarg5; if(!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< int,int > & type is null", 0);
    return 0; }   arg6 = (int)jarg6;  result = (bool)(arg1)->TraverseCycle(arg2,arg3,arg4,*arg5,arg6); jresult = result; 
  return jresult; }
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_CharPtrLess() { void * jresult ; OpenBabel::CharPtrLess *result = 0 ;
  result = (OpenBabel::CharPtrLess *)new OpenBabel::CharPtrLess(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_CharPtrLess(void * jarg1) {
  OpenBabel::CharPtrLess *arg1 = (OpenBabel::CharPtrLess *) 0 ; arg1 = (OpenBabel::CharPtrLess *)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 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_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_OBPlugin_Begin(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBPlugin::PluginIterator result; arg1 = (char *)jarg1;  result = OpenBabel::OBPlugin::Begin((char const *)arg1);
  jresult = new OpenBabel::OBPlugin::PluginIterator((const OpenBabel::OBPlugin::PluginIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBPlugin_End(char * jarg1) { void * jresult ; char *arg1 = (char *) 0 ;
  OpenBabel::OBPlugin::PluginIterator result; arg1 = (char *)jarg1;  result = OpenBabel::OBPlugin::End((char const *)arg1);
  jresult = new OpenBabel::OBPlugin::PluginIterator((const OpenBabel::OBPlugin::PluginIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBPlugin_GetMap(void * jarg1) { void * jresult ;
  OpenBabel::OBPlugin *arg1 = (OpenBabel::OBPlugin *) 0 ; OpenBabel::OBPlugin::PluginMapType *result = 0 ;
  arg1 = (OpenBabel::OBPlugin *)jarg1;  {
    OpenBabel::OBPlugin::PluginMapType &_result_ref = ((OpenBabel::OBPlugin const *)arg1)->GetMap();
    result = (OpenBabel::OBPlugin::PluginMapType *) &_result_ref; }  jresult = (void *)result;  return jresult; }
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 = 0 ;
  arg1 = (OpenBabel::OBMessageHandler *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMessageHandler const & type is null", 0);
    return ; }   OpenBabel::obErrorLog = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_obErrorLog_get() { void * jresult ; OpenBabel::OBMessageHandler *result = 0 ; {
    OpenBabel::OBMessageHandler const &_result_ref = OpenBabel::obErrorLog;
    result = (OpenBabel::OBMessageHandler *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_obLogBuf(void * jarg1) { OpenBabel::obLogBuf *arg1 = (OpenBabel::obLogBuf *) 0 ;
  arg1 = (OpenBabel::obLogBuf *)jarg1;  delete arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_obLogBuf() { void * jresult ; OpenBabel::obLogBuf *result = 0 ;
  result = (OpenBabel::obLogBuf *)new OpenBabel::obLogBuf(); jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NOTREADABLE_get() { int jresult ; int result; result = (int) 0x01; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_READONEONLY_get() { int jresult ; int result; result = (int) 0x02; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_READBINARY_get() { int jresult ; int result; result = (int) 0x04; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ZEROATOMSOK_get() { int jresult ; int result; result = (int) 0x08; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NOTWRITABLE_get() { int jresult ; int result; result = (int) 0x10; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_WRITEONEONLY_get() { int jresult ; int result; result = (int) 0x20; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_WRITEBINARY_get() { int jresult ; int result; result = (int) 0x40; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_READXML_get() { int jresult ; int result; result = (int) 0x80; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_DEFAULTFORMAT_get() { int jresult ; int result; result = (int) 0x4000; jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBFormat_Default() { void * jresult ; OpenBabel::OBFormat **result = 0 ; {
    OpenBabel::OBFormat *&_result_ref = OpenBabel::OBFormat::Default(); result = (OpenBabel::OBFormat **) &_result_ref; } 
  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 char * SWIGSTDCALL CSharp_OBFormat_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBFormat *)jarg1; 
  result = (char *)(arg1)->TypeID(); jresult = SWIG_csharp_string_callback((const char *)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 void * SWIGSTDCALL CSharp_OBFormat_GetType(void * jarg1) { void * jresult ;
  OpenBabel::OBFormat *arg1 = (OpenBabel::OBFormat *) 0 ; std::type_info *result = 0 ; arg1 = (OpenBabel::OBFormat *)jarg1;  {
    std::type_info const &_result_ref = (arg1)->GetType(); result = (std::type_info *) &_result_ref; } 
  jresult = (void *)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(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(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 unsigned int SWIGSTDCALL CSharp_OBConversion_GetNextFormat(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::Formatpos *arg1 = 0 ; char **arg2 = 0 ; OpenBabel::OBFormat **arg3 = 0 ; char *temp2 = 0 ;
  OpenBabel::OBFormat *temp3 = 0 ; bool result; arg1 = (OpenBabel::Formatpos *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::Formatpos & type is null", 0);
    return 0; }   temp2 = (char *)jarg2; arg2 = &temp2; temp3 = (OpenBabel::OBFormat *)jarg3; arg3 = &temp3; 
  result = (bool)OpenBabel::OBConversion::GetNextFormat(*arg1,(char const *&)*arg2,*arg3); jresult = 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 void * SWIGSTDCALL CSharp_OBConversion_GetInPos(void * jarg1) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; std::streampos result;
  arg1 = (OpenBabel::OBConversion *)jarg1;  result = ((OpenBabel::OBConversion const *)arg1)->GetInPos();
  jresult = new std::streampos((const std::streampos &)result);  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_GetOptions(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBConversion *arg1 = (OpenBabel::OBConversion *) 0 ; OpenBabel::OBConversion::Option_type arg2 ;
  std::map< std::string,std::string > *result = 0 ; arg1 = (OpenBabel::OBConversion *)jarg1; 
  arg2 = (OpenBabel::OBConversion::Option_type)jarg2;  result = (std::map< std::string,std::string > *)(arg1)->GetOptions(arg2);
  jresult = (void *)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 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 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 ; SwigValueWrapper< 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 ;
  SwigValueWrapper< 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 ; SwigValueWrapper< 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_OBResidue_BeginAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (arg1)->BeginAtoms(); jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_EndAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result; arg1 = (OpenBabel::OBResidue *)jarg1; 
  result = (arg1)->EndAtoms(); jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_BeginAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::vector< OpenBabel::OBAtom * >::iterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->BeginAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidue_NextAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidue *arg1 = (OpenBabel::OBResidue *) 0 ; std::vector< OpenBabel::OBAtom * >::iterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidue *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->NextAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MAXSETNO_get() { int jresult ; int result; result = (int) 40; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MAXELEM_get() { int jresult ; int result; result = (int) 1024; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MINELEM_get() { int jresult ; int result; result = (int) 29; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MAXRES_get() { int jresult ; int result; result = (int) 100; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MINRES_get() { int jresult ; int result; result = (int) 54; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_ALA_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_GLY_get() { int jresult ; int result; result = (int) (1 << 2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_LEU_get() { int jresult ; int result; result = (int) (1 << 3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_SER_get() { int jresult ; int result; result = (int) (1 << 4); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_VAL_get() { int jresult ; int result; result = (int) (1 << 5); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_THR_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_LYS_get() { int jresult ; int result; result = (int) (1 << 7); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_ASP_get() { int jresult ; int result; result = (int) (1 << 8); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_ILE_get() { int jresult ; int result; result = (int) (1 << 9); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_ASN_get() { int jresult ; int result; result = (int) (1 << 10); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_GLU_get() { int jresult ; int result; result = (int) (1 << 11); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_PRO_get() { int jresult ; int result; result = (int) (1 << 12); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_ARG_get() { int jresult ; int result; result = (int) (1 << 13); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_PHE_get() { int jresult ; int result; result = (int) (1 << 14); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_GLN_get() { int jresult ; int result; result = (int) (1 << 15); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_TYR_get() { int jresult ; int result; result = (int) (1 << 16); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_HIS_get() { int jresult ; int result; result = (int) (1 << 17); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_CYS_get() { int jresult ; int result; result = (int) (1 << 18); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_MET_get() { int jresult ; int result; result = (int) (1 << 19); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AA_TRP_get() { int jresult ; int result; result = (int) (1 << 20); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ACIDIC_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::ACIDIC;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ACYCLIC_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::ACYCLIC; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ALIPHATIC_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::ALIPHATIC; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AROMATIC_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::AROMATIC; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_BASIC_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::BASIC;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_BURIED_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::BURIED;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CHARGED_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::CHARGED; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CYCLIC_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::CYCLIC;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_HYDROPHOBIC_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::HYDROPHOBIC; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LARGE_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::LARGE;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MEDIUM_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::MEDIUM;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NEGATIVE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::NEGATIVE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NEUTRAL_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::NEUTRAL; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_POLAR_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::POLAR;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_POSITIVE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::POSITIVE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SMALL_get() { int jresult ; int result; result = (int)OpenBabel::OBAminoAcidProperty::SMALL;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SURFACE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBAminoAcidProperty::SURFACE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ALPHA_CARBON_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::ALPHA_CARBON; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AMINO_BACKBONE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::AMINO_BACKBONE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_BACKBONE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::BACKBONE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CYSTEINE_SULPHUR_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::CYSTEINE_SULPHUR; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LIGAND_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::LIGAND; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NUCLEIC_BACKBONE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::NUCLEIC_BACKBONE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SHAPELY_BACKBONE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::SHAPELY_BACKBONE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SHAPELY_SPECIAL_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::SHAPELY_SPECIAL; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SIDECHAIN_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::SIDECHAIN; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SUGAR_PHOSPHATE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueAtomProperty::SUGAR_PHOSPHATE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ALA_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ALA;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_GLY_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::GLY;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LEU_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::LEU;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SER_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::SER;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_VAL_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::VAL;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_THR_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::THR;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LYS_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::LYS;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ASP_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ASP;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ILE_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ILE;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ASN_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ASN;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_GLU_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::GLU;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PRO_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::PRO;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ARG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ARG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PHE_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::PHE;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_GLN_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::GLN;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_TYR_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::TYR;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_HIS_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::HIS;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_CYS_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::CYS;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_MET_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::MET;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_TRP_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::TRP;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ASX_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ASX;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_GLX_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::GLX;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PCA_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::PCA;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_HYP_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::HYP;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_A_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::A;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_C_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::C;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_G_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::G;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_T_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::T;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_U_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::U;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_UPLUS_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::UPLUS;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_I_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::I;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__1MA_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_1MA;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__5MC_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_5MC;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OMC_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::OMC;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__1MG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_1MG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__2MG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_2MG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_M2G_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::M2G;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__7MG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_7MG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OMG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::OMG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_YG_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::YG;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_H2U_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::H2U;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp__5MU_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::_5MU;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PSU_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::PSU;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_UNK_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::UNK;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ACE_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::ACE;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_FOR_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::FOR;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_HOH_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::HOH;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_DOD_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::DOD;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SO4_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::SO4;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PO4_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::PO4;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NAD_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::NAD;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_COA_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::COA;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NAP_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::NAP;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NDP_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueIndex::NDP;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AMINO_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::AMINO;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_AMINO_NUCLEO_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueProperty::AMINO_NUCLEO; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_COENZYME_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueProperty::COENZYME; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_ION_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::ION;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_NUCLEO_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::NUCLEO;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PROTEIN_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::PROTEIN;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PURINE_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::PURINE;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_PYRIMIDINE_get() { int jresult ; int result;
  result = (int)OpenBabel::OBResidueProperty::PYRIMIDINE; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_SOLVENT_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::SOLVENT;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_WATER_get() { int jresult ; int result; result = (int)OpenBabel::OBResidueProperty::WATER;
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_Residue_set(void * jarg1) { char (*arg1)[4] ; arg1 = (char (*)[4])jarg1;  {
    char (*inp)[4] = (char (*)[4])(arg1); char (*dest)[4] = (char (*)[4])(OpenBabel::Residue); size_t ii = 0;
    for (; ii < 100; ++ii) { char *ip = inp[ii]; char *dp = dest[ii]; size_t jj = 0; for (; jj < 4; ++jj) dp[jj] = ip[jj]; }  }
   }
SWIGEXPORT void * SWIGSTDCALL CSharp_Residue_get() { void * jresult ; char (*result)[4] = 0 ;
  result = (char (*)[4])(char (*)[4])OpenBabel::Residue; jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ElemDesc_set(void * jarg1) { char (*arg1)[4] ; arg1 = (char (*)[4])jarg1;  {
    char (*inp)[4] = (char (*)[4])(arg1); char (*dest)[4] = (char (*)[4])(OpenBabel::ElemDesc); size_t ii = 0;
    for (; ii < 1024; ++ii) { char *ip = inp[ii]; char *dp = dest[ii]; size_t jj = 0; for (; jj < 4; ++jj) dp[jj] = ip[jj]; }  }
   }
SWIGEXPORT void * SWIGSTDCALL CSharp_ElemDesc_get() { void * jresult ; char (*result)[4] = 0 ;
  result = (char (*)[4])(char (*)[4])OpenBabel::ElemDesc; jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ResNo_set(unsigned int jarg1) { unsigned int arg1 ; arg1 = (unsigned int)jarg1; 
  OpenBabel::ResNo = arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ResNo_get() { unsigned int jresult ; unsigned int result;
  result = (unsigned int)OpenBabel::ResNo; jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ElemNo_set(unsigned int jarg1) { unsigned int arg1 ; arg1 = (unsigned int)jarg1; 
  OpenBabel::ElemNo = arg1; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ElemNo_get() { unsigned int jresult ; unsigned int result;
  result = (unsigned int)OpenBabel::ElemNo; 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 int SWIGSTDCALL CSharp_OB_4RING_ATOM_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_3RING_ATOM_get() { int jresult ; int result; result = (int) (1 << 2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_AROMATIC_ATOM_get() { int jresult ; int result; result = (int) (1 << 3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_RING_ATOM_get() { int jresult ; int result; result = (int) (1 << 4); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CSTEREO_ATOM_get() { int jresult ; int result; result = (int) (1 << 5); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_ACSTEREO_ATOM_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_DONOR_ATOM_get() { int jresult ; int result; result = (int) (1 << 7); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_ACCEPTOR_ATOM_get() { int jresult ; int result; result = (int) (1 << 8); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CHIRAL_ATOM_get() { int jresult ; int result; result = (int) (1 << 9); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_POS_CHIRAL_ATOM_get() { int jresult ; int result; result = (int) (1 << 10);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_NEG_CHIRAL_ATOM_get() { int jresult ; int result; result = (int) (1 << 11);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_ATOM_HAS_NO_H_get() { int jresult ; int result; result = (int) (1 << 12);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_ATOM_NOT_H_DEFICIENT_get() { int jresult ; int result; result = (int) (1 << 13);
  jresult = result;  return jresult; }
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_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_SetType__SWIG_0(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_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_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; double **arg2 = (double **) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (double **)jarg2;  (arg1)->SetCoordPtr(arg2); }
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 void SWIGSTDCALL CSharp_OBAtom_ClearCoordPtr(void * jarg1) { OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  (arg1)->ClearCoordPtr(); }
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_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_GetType(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;  {
    OpenBabel::vector3 &_result_ref = (arg1)->GetVector(); result = (OpenBabel::vector3 *) &_result_ref; } 
  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 void * SWIGSTDCALL CSharp_OBAtom_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  result = (arg1)->BeginBonds();
  jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result;
  arg1 = (OpenBabel::OBAtom *)jarg1;  result = (arg1)->EndBonds();
  jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtom_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtom *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->NextNbrAtom(*arg2); 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 void SWIGSTDCALL CSharp_OBAtom_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBAtom *arg1 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBAtom *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (arg1)->InsertBond(*arg2,arg3); }
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(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 int SWIGSTDCALL CSharp_OB_AROMATIC_BOND_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_WEDGE_BOND_get() { int jresult ; int result; result = (int) (1 << 2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_HASH_BOND_get() { int jresult ; int result; result = (int) (1 << 3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_RING_BOND_get() { int jresult ; int result; result = (int) (1 << 4); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_TORUP_BOND_get() { int jresult ; int result; result = (int) (1 << 5); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_TORDOWN_BOND_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_KSINGLE_BOND_get() { int jresult ; int result; result = (int) (1 << 7); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_KDOUBLE_BOND_get() { int jresult ; int result; result = (int) (1 << 8); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_KTRIPLE_BOND_get() { int jresult ; int result; result = (int) (1 << 9); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CLOSURE_BOND_get() { int jresult ; int result; result = (int) (1 << 10); 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_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_SetHash(void * jarg1) { OpenBabel::OBBond *arg1 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBBond *)jarg1;  (arg1)->SetHash(); }
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_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(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 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 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_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_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 int SWIGSTDCALL CSharp_OB_SSSR_MOL_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_RINGFLAGS_MOL_get() { int jresult ; int result; result = (int) (1 << 2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_AROMATIC_MOL_get() { int jresult ; int result; result = (int) (1 << 3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_ATOMTYPES_MOL_get() { int jresult ; int result; result = (int) (1 << 4); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CHIRALITY_MOL_get() { int jresult ; int result; result = (int) (1 << 5); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_PCHARGE_MOL_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_HYBRID_MOL_get() { int jresult ; int result; result = (int) (1 << 8); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_IMPVAL_MOL_get() { int jresult ; int result; result = (int) (1 << 9); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_KEKULE_MOL_get() { int jresult ; int result; result = (int) (1 << 10); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CLOSURE_MOL_get() { int jresult ; int result; result = (int) (1 << 11); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_H_ADDED_MOL_get() { int jresult ; int result; result = (int) (1 << 12); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_PH_CORRECTED_MOL_get() { int jresult ; int result; result = (int) (1 << 13);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_AROM_CORRECTED_MOL_get() { int jresult ; int result; result = (int) (1 << 14);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CHAINS_MOL_get() { int jresult ; int result; result = (int) (1 << 15); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_TCHARGE_MOL_get() { int jresult ; int result; result = (int) (1 << 16); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_TSPIN_MOL_get() { int jresult ; int result; result = (int) (1 << 17); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_RINGTYPES_MOL_get() { int jresult ; int result; result = (int) (1 << 18);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OB_CURRENT_CONFORMER_get() { int jresult ; int result; result = (int) -1; 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(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_NewBond(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_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_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_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 ; SwigValueWrapper< 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;  { std::vector< OpenBabel::OBRing * > &_result_ref = (arg1)->GetSSSR();
    result = (std::vector< OpenBabel::OBRing * > *) &_result_ref; }  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_SetTitle__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; char *arg2 = (char *) 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (char *)jarg2;  (arg1)->SetTitle((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_SetTitle__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::string *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  (arg1)->SetTitle(*arg2); }
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 ; SwigValueWrapper< 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_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(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_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)[3] ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (double (*)[3])jarg2;  (arg1)->Rotate((double const (*)[3])arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMol_Rotate__SWIG_1(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_2(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(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 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_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_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(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_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_OBMol_BeginConformer(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double * >::iterator *arg2 = 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< double * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double * >::iterator & type is null", 0);
    return 0; }   result = (double *)(arg1)->BeginConformer(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NextConformer(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double * >::iterator *arg2 = 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (std::vector< double * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double * >::iterator & type is null", 0);
    return 0; }   result = (double *)(arg1)->NextConformer(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_GetConformers(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< double * > *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1;  {
    std::vector< double * > &_result_ref = (arg1)->GetConformers(); result = (std::vector< double * > *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->BeginAtoms();
  jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_EndAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->EndAtoms();
  jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->BeginBonds();
  jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->EndBonds();
  jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginResidues(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBResidue * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->BeginResidues();
  jresult = new OpenBabel::OBResidueIterator((const OpenBabel::OBResidueIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_EndResidues(void * jarg1) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; SwigValueWrapper< std::vector< OpenBabel::OBResidue * >::iterator > result;
  arg1 = (OpenBabel::OBMol *)jarg1;  result = (arg1)->EndResidues();
  jresult = new OpenBabel::OBResidueIterator((const OpenBabel::OBResidueIterator &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtomIterator *arg2 = 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtomIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtomIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->BeginAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NextAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBAtomIterator *arg2 = 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBAtomIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtomIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(arg1)->NextAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginResidue(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidueIterator *arg2 = 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBResidueIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidueIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBResidue *)(arg1)->BeginResidue(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NextResidue(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; OpenBabel::OBResidueIterator *arg2 = 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMol *)jarg1;  arg2 = (OpenBabel::OBResidueIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidueIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBResidue *)(arg1)->NextResidue(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_BeginInternalCoord(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBInternalCoord * >::iterator *arg2 = 0 ;
  OpenBabel::OBInternalCoord *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBInternalCoord * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBInternalCoord *)(arg1)->BeginInternalCoord(*arg2); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMol_NextInternalCoord(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMol *arg1 = (OpenBabel::OBMol *) 0 ; std::vector< OpenBabel::OBInternalCoord * >::iterator *arg2 = 0 ;
  OpenBabel::OBInternalCoord *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBInternalCoord * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBInternalCoord * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBInternalCoord *)(arg1)->NextInternalCoord(*arg2); jresult = (void *)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 = 0 ;
  arg1 = (OpenBabel::OBElementTable *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBElementTable const & type is null", 0);
    return ; }   OpenBabel::etab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_etab_get() { void * jresult ; OpenBabel::OBElementTable *result = 0 ; {
    OpenBabel::OBElementTable const &_result_ref = OpenBabel::etab; result = (OpenBabel::OBElementTable *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_ttab_set(void * jarg1) { OpenBabel::OBTypeTable *arg1 = 0 ;
  arg1 = (OpenBabel::OBTypeTable *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBTypeTable const & type is null", 0);
    return ; }   OpenBabel::ttab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_ttab_get() { void * jresult ; OpenBabel::OBTypeTable *result = 0 ; {
    OpenBabel::OBTypeTable const &_result_ref = OpenBabel::ttab; result = (OpenBabel::OBTypeTable *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_isotab_set(void * jarg1) { OpenBabel::OBIsotopeTable *arg1 = 0 ;
  arg1 = (OpenBabel::OBIsotopeTable *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBIsotopeTable const & type is null", 0);
    return ; }   OpenBabel::isotab = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_isotab_get() { void * jresult ; OpenBabel::OBIsotopeTable *result = 0 ; {
    OpenBabel::OBIsotopeTable const &_result_ref = OpenBabel::isotab; result = (OpenBabel::OBIsotopeTable *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_aromtyper_set(void * jarg1) { OpenBabel::OBAromaticTyper *arg1 = 0 ;
  arg1 = (OpenBabel::OBAromaticTyper *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAromaticTyper const & type is null", 0);
    return ; }   OpenBabel::aromtyper = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_aromtyper_get() { void * jresult ; OpenBabel::OBAromaticTyper *result = 0 ; {
    OpenBabel::OBAromaticTyper const &_result_ref = OpenBabel::aromtyper; result = (OpenBabel::OBAromaticTyper *) &_result_ref; }
   jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_atomtyper_set(void * jarg1) { OpenBabel::OBAtomTyper *arg1 = 0 ;
  arg1 = (OpenBabel::OBAtomTyper *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBAtomTyper const & type is null", 0);
    return ; }   OpenBabel::atomtyper = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_atomtyper_get() { void * jresult ; OpenBabel::OBAtomTyper *result = 0 ; {
    OpenBabel::OBAtomTyper const &_result_ref = OpenBabel::atomtyper; result = (OpenBabel::OBAtomTyper *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_chainsparser_set(void * jarg1) { OpenBabel::OBChainsParser *arg1 = 0 ;
  arg1 = (OpenBabel::OBChainsParser *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBChainsParser const & type is null", 0);
    return ; }   OpenBabel::chainsparser = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_chainsparser_get() { void * jresult ; OpenBabel::OBChainsParser *result = 0 ; {
    OpenBabel::OBChainsParser const &_result_ref = OpenBabel::chainsparser;
    result = (OpenBabel::OBChainsParser *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_resdat_set(void * jarg1) { OpenBabel::OBResidueData *arg1 = 0 ;
  arg1 = (OpenBabel::OBResidueData *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBResidueData const & type is null", 0);
    return ; }   OpenBabel::resdat = *arg1; }
SWIGEXPORT void * SWIGSTDCALL CSharp_resdat_get() { void * jresult ; OpenBabel::OBResidueData *result = 0 ; {
    OpenBabel::OBResidueData const &_result_ref = OpenBabel::resdat; result = (OpenBabel::OBResidueData *) &_result_ref; } 
  jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_BUFF_SIZE_get() { int jresult ; int result; result = (int) 32768; jresult = 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 void SWIGSTDCALL CSharp_ob_make_rmat(void * jarg1, void * jarg2) { double (*arg1)[3] ; double *arg2 ;
  arg1 = (double (*)[3])jarg1;  arg2 = (double *)jarg2;  OpenBabel::ob_make_rmat((double (*)[3])arg1,arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_qtrfit(void * jarg1, void * jarg2, int jarg3, void * jarg4) { double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ; int arg3 ; double (*arg4)[3] ; arg1 = (double *)jarg1;  arg2 = (double *)jarg2; 
  arg3 = (int)jarg3;  arg4 = (double (*)[3])jarg4;  OpenBabel::qtrfit(arg1,arg2,arg3,(double (*)[3])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__path_set(void * jarg1, void * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; std::vector< int > *arg2 = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   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;  {
    std::vector< int > const &_result_ref =  ((arg1)->_path); result = (std::vector< int > *) &_result_ref; } 
  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 = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (OpenBabel::OBBitVec *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec const & type is null", 0);
    return ; }   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;  {
    OpenBabel::OBBitVec const &_result_ref =  ((arg1)->_pathset); result = (OpenBabel::OBBitVec *) &_result_ref; } 
  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 int SWIGSTDCALL CSharp_OBRing_Size(void * jarg1) { int jresult ; OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ;
  int result; arg1 = (OpenBabel::OBRing *)jarg1;  result = (int)((OpenBabel::OBRing const *)arg1)->Size(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBRing_PathSize(void * jarg1) { int jresult ;
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; int result; arg1 = (OpenBabel::OBRing *)jarg1; 
  result = (int)((OpenBabel::OBRing const *)arg1)->PathSize(); jresult = 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__SWIG_0(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 void SWIGSTDCALL CSharp_OBRing_SetType__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBRing *arg1 = (OpenBabel::OBRing *) 0 ; std::string *arg2 = 0 ; arg1 = (OpenBabel::OBRing *)jarg1; 
  arg2 = (std::string *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  (arg1)->SetType(*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBRing_GetType(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_OBRingSearch() { void * jresult ; OpenBabel::OBRingSearch *result = 0 ;
  result = (OpenBabel::OBRingSearch *)new OpenBabel::OBRingSearch(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBRingSearch(void * jarg1) {
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; arg1 = (OpenBabel::OBRingSearch *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingSearch_SortRings(void * jarg1) {
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  (arg1)->SortRings(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingSearch_RemoveRedundant(void * jarg1, int jarg2) {
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; int arg2 ; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  arg2 = (int)jarg2;  (arg1)->RemoveRedundant(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingSearch_AddRingFromClosure(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; OpenBabel::OBMol *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  arg2 = (OpenBabel::OBMol *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0); return ; }  
  arg3 = (OpenBabel::OBBond *)jarg3;  (arg1)->AddRingFromClosure(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBRingSearch_SaveUniqueRing(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; std::deque< int > *arg2 = 0 ;
  std::deque< int > *arg3 = 0 ; bool result; arg1 = (OpenBabel::OBRingSearch *)jarg1;  arg2 = (std::deque< int > *)jarg2;
  if(!arg2) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::deque< int > & type is null", 0);
    return 0; }   arg3 = (std::deque< int > *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::deque< int > & type is null", 0); return 0; }
    result = (bool)(arg1)->SaveUniqueRing(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBRingSearch_WriteRings(void * jarg1) {
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  (arg1)->WriteRings(); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingSearch_BeginRings(void * jarg1) { void * jresult ;
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBRing * >::iterator > result; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  result = (arg1)->BeginRings();
  jresult = new std::vector< OpenBabel::OBRing * >::iterator((const std::vector< OpenBabel::OBRing * >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBRingSearch_EndRings(void * jarg1) { void * jresult ;
  OpenBabel::OBRingSearch *arg1 = (OpenBabel::OBRingSearch *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBRing * >::iterator > result; arg1 = (OpenBabel::OBRingSearch *)jarg1; 
  result = (arg1)->EndRings();
  jresult = new std::vector< OpenBabel::OBRing * >::iterator((const std::vector< OpenBabel::OBRing * >::iterator &)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;  {
    std::string const &_result_ref = ((OpenBabel::OBSmartsPattern const *)arg1)->GetSMARTS();
    result = (std::string *) &_result_ref; }  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_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 ;
  std::vector< std::pair< int,int > > *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 = (std::vector< std::pair< int,int > > *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< int,int > > & 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 ;
  std::vector< std::pair< int,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::pair< int,int > > *)jarg3; if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< int,int > > & type is null", 0);
    return 0; }   result = (bool)(arg1)->RestrictedMatch(*arg2,*arg3); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBSmartsPattern_RestrictedMatch__SWIG_2(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_3(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;  { std::vector< std::vector< int > > &_result_ref = (arg1)->GetMapList();
    result = (std::vector< std::vector< int > > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSmartsPattern_BeginMList(void * jarg1) { void * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ;
  SwigValueWrapper< std::vector< std::vector< int > >::iterator > result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  result = (arg1)->BeginMList();
  jresult = new std::vector< std::vector< int > >::iterator((const std::vector< std::vector< int > >::iterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBSmartsPattern_EndMList(void * jarg1) { void * jresult ;
  OpenBabel::OBSmartsPattern *arg1 = (OpenBabel::OBSmartsPattern *) 0 ;
  SwigValueWrapper< std::vector< std::vector< int > >::iterator > result; arg1 = (OpenBabel::OBSmartsPattern *)jarg1; 
  result = (arg1)->EndMList();
  jresult = new std::vector< std::vector< int > >::iterator((const std::vector< std::vector< int > >::iterator &)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;  { std::vector< std::vector< int > > &_result_ref = (arg1)->GetUMapList();
    result = (std::vector< std::vector< int > > *) &_result_ref; }  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_OBSSMatch(void * jarg1, void * jarg2) { void * jresult ; OpenBabel::OBMol *arg1 = 0 ;
  OpenBabel::Pattern *arg2 = (OpenBabel::Pattern *) 0 ; OpenBabel::OBSSMatch *result = 0 ; arg1 = (OpenBabel::OBMol *)jarg1;
  if(!arg1) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBMol & type is null", 0);
    return 0; }   arg2 = (OpenBabel::Pattern *)jarg2;  result = (OpenBabel::OBSSMatch *)new OpenBabel::OBSSMatch(*arg1,arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_OBSSMatch(void * jarg1) { OpenBabel::OBSSMatch *arg1 = (OpenBabel::OBSSMatch *) 0 ;
  arg1 = (OpenBabel::OBSSMatch *)jarg1;  delete arg1; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSSMatch_Match__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  OpenBabel::OBSSMatch *arg1 = (OpenBabel::OBSSMatch *) 0 ; std::vector< std::vector< int > > *arg2 = 0 ; int arg3 ;
  arg1 = (OpenBabel::OBSSMatch *)jarg1;  arg2 = (std::vector< std::vector< int > > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > & type is null", 0);
    return ; }   arg3 = (int)jarg3;  (arg1)->Match(*arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBSSMatch_Match__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBSSMatch *arg1 = (OpenBabel::OBSSMatch *) 0 ; std::vector< std::vector< int > > *arg2 = 0 ;
  arg1 = (OpenBabel::OBSSMatch *)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)->Match(*arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_SmartsLexReplace(void * jarg1, void * jarg2) { std::string *arg1 = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg2 = 0 ; arg1 = (std::string *)jarg1; if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  arg2 = (std::vector< std::pair< std::string,std::string > > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< std::string,std::string > > & type is null", 0);
    return ; }   OpenBabel::SmartsLexReplace(*arg1,*arg2); }
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(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 void SWIGSTDCALL CSharp_AliasData_SetExpandedAtoms(void * jarg1, void * jarg2) {
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::vector< unsigned int > *arg2 = 0 ;
  arg1 = (OpenBabel::AliasData *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > & type is null", 0);
    return ; }   (arg1)->SetExpandedAtoms(*arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_AliasData_GetExpandedAtoms(void * jarg1) { void * jresult ;
  OpenBabel::AliasData *arg1 = (OpenBabel::AliasData *) 0 ; std::vector< unsigned int > result;
  arg1 = (OpenBabel::AliasData *)jarg1;  result = ((OpenBabel::AliasData const *)arg1)->GetExpandedAtoms();
  jresult = new std::vector< unsigned int >((const std::vector< unsigned int > &)result);  return jresult; }
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 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 ; {
    OpenBabel::OBFingerprint *&_result_ref = OpenBabel::OBFingerprint::Default();
    result = (OpenBabel::OBFingerprint **) &_result_ref; }  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 char * SWIGSTDCALL CSharp_OBFingerprint_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBFingerprint *arg1 = (OpenBabel::OBFingerprint *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBFingerprint *)jarg1;  result = (char *)(arg1)->TypeID();
  jresult = SWIG_csharp_string_callback((const char *)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 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); 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);
    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 void SWIGSTDCALL CSharp_FptIndex_header_set(void * jarg1, void * jarg2) {
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; OpenBabel::FptIndexHeader *arg2 = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (OpenBabel::FptIndexHeader *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::FptIndexHeader const & type is null", 0);
    return ; }   if (arg1) (arg1)->header = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FptIndex_header_get(void * jarg1) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; OpenBabel::FptIndexHeader *result = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  { OpenBabel::FptIndexHeader const &_result_ref =  ((arg1)->header);
    result = (OpenBabel::FptIndexHeader *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndex_fptdata_set(void * jarg1, void * jarg2) {
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::vector< unsigned int > *arg2 = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   if (arg1) (arg1)->fptdata = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FptIndex_fptdata_get(void * jarg1) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::vector< unsigned int > *result = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  { std::vector< unsigned int > const &_result_ref =  ((arg1)->fptdata);
    result = (std::vector< unsigned int > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_FptIndex_seekdata_set(void * jarg1, void * jarg2) {
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::vector< unsigned int > *arg2 = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (std::vector< unsigned int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ; }   if (arg1) (arg1)->seekdata = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FptIndex_seekdata_get(void * jarg1) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::vector< unsigned int > *result = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  { std::vector< unsigned int > const &_result_ref =  ((arg1)->seekdata);
    result = (std::vector< unsigned int > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_FptIndex_Read(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; std::istream *arg2 = (std::istream *) 0 ; bool result;
  arg1 = (OpenBabel::FptIndex *)jarg1;  arg2 = (std::istream *)jarg2;  result = (bool)(arg1)->Read(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_FptIndex_CheckFP(void * jarg1) { void * jresult ;
  OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ; OpenBabel::OBFingerprint *result = 0 ;
  arg1 = (OpenBabel::FptIndex *)jarg1;  result = (OpenBabel::OBFingerprint *)(arg1)->CheckFP(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_FptIndex() { void * jresult ; OpenBabel::FptIndex *result = 0 ;
  result = (OpenBabel::FptIndex *)new OpenBabel::FptIndex(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_delete_FptIndex(void * jarg1) { OpenBabel::FptIndex *arg1 = (OpenBabel::FptIndex *) 0 ;
  arg1 = (OpenBabel::FptIndex *)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) {
  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_1(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_2(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;  {
    OpenBabel::FptIndexHeader const &_result_ref = ((OpenBabel::FastSearch const *)arg1)->GetIndexHeader();
    result = (OpenBabel::FptIndexHeader *) &_result_ref; }  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) {
  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_1(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_2(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 unsigned int SWIGSTDCALL CSharp_FastSearchIndexer_Add(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ; OpenBabel::FastSearchIndexer *arg1 = (OpenBabel::FastSearchIndexer *) 0 ;
  OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ; std::streampos arg3 ; std::streampos *argp3 ; bool result;
  arg1 = (OpenBabel::FastSearchIndexer *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  argp3 = (std::streampos *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::streampos", 0);
    return 0; }  arg3 = *argp3;  result = (bool)(arg1)->Add(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBDescriptor_Default() { void * jresult ; OpenBabel::OBDescriptor **result = 0 ; {
    OpenBabel::OBDescriptor *&_result_ref = OpenBabel::OBDescriptor::Default();
    result = (OpenBabel::OBDescriptor **) &_result_ref; }  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 char * SWIGSTDCALL CSharp_OBDescriptor_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBDescriptor *)jarg1; 
  result = (char *)(arg1)->TypeID(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBDescriptor_Predict(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(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(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(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_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_delete_OBDescriptor(void * jarg1) {
  OpenBabel::OBDescriptor *arg1 = (OpenBabel::OBDescriptor *) 0 ; arg1 = (OpenBabel::OBDescriptor *)jarg1;  delete arg1; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_LOGLVL_NONE_get() { int jresult ; int result; result = (int) 0; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_LOGLVL_LOW_get() { int jresult ; int result; result = (int) 1; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_LOGLVL_MEDIUM_get() { int jresult ; int result; result = (int) 2; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_LOGLVL_HIGH_get() { int jresult ; int result; result = (int) 3; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_ENERGY_get() { int jresult ; int result; result = (int) (1 << 0); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_EBOND_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_EANGLE_get() { int jresult ; int result; result = (int) (1 << 2); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_ESTRBND_get() { int jresult ; int result; result = (int) (1 << 3); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_ETORSION_get() { int jresult ; int result; result = (int) (1 << 4); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_EOOP_get() { int jresult ; int result; result = (int) (1 << 5); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_EVDW_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_EELECTROSTATIC_get() { int jresult ; int result; result = (int) (1 << 7);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_IGNORE_get() { int jresult ; int result; result = (int) (1 << 0);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_ATOM_get() { int jresult ; int result; result = (int) (1 << 1); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_ATOM_X_get() { int jresult ; int result; result = (int) (1 << 2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_ATOM_Y_get() { int jresult ; int result; result = (int) (1 << 3);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_ATOM_Z_get() { int jresult ; int result; result = (int) (1 << 4);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_DISTANCE_get() { int jresult ; int result; result = (int) (1 << 5);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_ANGLE_get() { int jresult ; int result; result = (int) (1 << 6); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_TORSION_get() { int jresult ; int result; result = (int) (1 << 7);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_CONST_CHIRAL_get() { int jresult ; int result; result = (int) (1 << 8);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_NUMERICAL_GRADIENT_get() { int jresult ; int result; result = (int) (1 << 0);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBFF_ANALYTICAL_GRADIENT_get() { int jresult ; int result; result = (int) (1 << 1);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_KCAL_TO_KJ_get() { double jresult ; double result; result = (double) 4.1868;
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LineSearchType_Simple_get() { int jresult ; int result;
  result = (int)OpenBabel::LineSearchType::Simple; jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_LineSearchType_Newton2Num_get() { int jresult ; int result;
  result = (int)OpenBabel::LineSearchType::Newton2Num; jresult = result;  return jresult; }
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;  { std::string const &_result_ref =  ((arg1)->_a);
    result = (std::string *) &_result_ref; }  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;  { std::string const &_result_ref =  ((arg1)->_b);
    result = (std::string *) &_result_ref; }  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;  { std::string const &_result_ref =  ((arg1)->_c);
    result = (std::string *) &_result_ref; }  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;  { std::string const &_result_ref =  ((arg1)->_d);
    result = (std::string *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  arg2 = (std::vector< int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   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;  { std::vector< int > const &_result_ref =  ((arg1)->_ipar);
    result = (std::vector< int > *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFParameter *)jarg1;  arg2 = (std::vector< double > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ; }   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;  { std::vector< double > const &_result_ref =  ((arg1)->_dpar);
    result = (std::vector< double > *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   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;  { OpenBabel::vector3 const &_result_ref =  ((arg1)->grada);
    result = (OpenBabel::vector3 *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   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;  { OpenBabel::vector3 const &_result_ref =  ((arg1)->gradb);
    result = (OpenBabel::vector3 *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   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;  { OpenBabel::vector3 const &_result_ref =  ((arg1)->gradc);
    result = (OpenBabel::vector3 *) &_result_ref; }  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 = 0 ;
  arg1 = (OpenBabel::OBFFConstraint *)jarg1;  arg2 = (OpenBabel::vector3 *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::vector3 const & type is null", 0);
    return ; }   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;  { OpenBabel::vector3 const &_result_ref =  ((arg1)->gradd);
    result = (OpenBabel::vector3 *) &_result_ref; }  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_OBForceField_Default() { void * jresult ; OpenBabel::OBForceField **result = 0 ; {
    OpenBabel::OBForceField *&_result_ref = OpenBabel::OBForceField::Default();
    result = (OpenBabel::OBForceField **) &_result_ref; }  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 char * SWIGSTDCALL CSharp_OBForceField_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBForceField *arg1 = (OpenBabel::OBForceField *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBForceField *)jarg1; 
  result = (char *)(arg1)->TypeID(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
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;  { OpenBabel::OBFFConstraints &_result_ref = (arg1)->GetConstraints();
    result = (OpenBabel::OBFFConstraints *) &_result_ref; }  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__SWIG_0(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__SWIG_0(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_OBOp_Default() { void * jresult ; OpenBabel::OBOp **result = 0 ; {
    OpenBabel::OBOp *&_result_ref = OpenBabel::OBOp::Default(); result = (OpenBabel::OBOp **) &_result_ref; } 
  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 char * SWIGSTDCALL CSharp_OBOp_TypeID(void * jarg1) { char * jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; char *result = 0 ; arg1 = (OpenBabel::OBOp *)jarg1; 
  result = (char *)(arg1)->TypeID(); jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_0(void * jarg1, void * jarg2, void * jarg3, char * jarg4) {
  unsigned int jresult ; OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  OpenBabel::OBOp::OpMap *arg3 = (OpenBabel::OBOp::OpMap *) 0 ; char *arg4 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBOp *)jarg1;  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (OpenBabel::OBOp::OpMap *)jarg3; 
  arg4 = (char *)jarg4;  result = (bool)(arg1)->Do(arg2,arg3,(char const *)arg4); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { unsigned int jresult ;
  OpenBabel::OBOp *arg1 = (OpenBabel::OBOp *) 0 ; OpenBabel::OBBase *arg2 = (OpenBabel::OBBase *) 0 ;
  OpenBabel::OBOp::OpMap *arg3 = (OpenBabel::OBOp::OpMap *) 0 ; bool result; arg1 = (OpenBabel::OBOp *)jarg1; 
  arg2 = (OpenBabel::OBBase *)jarg2;  arg3 = (OpenBabel::OBOp::OpMap *)jarg3;  result = (bool)(arg1)->Do(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBOp_Do__SWIG_2(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 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) { unsigned int jresult ;
  OpenBabel::OBBase *arg1 = (OpenBabel::OBBase *) 0 ; OpenBabel::OBOp::OpMap *arg2 = (OpenBabel::OBOp::OpMap *) 0 ; bool result;
  arg1 = (OpenBabel::OBBase *)jarg1;  arg2 = (OpenBabel::OBOp::OpMap *)jarg2; 
  result = (bool)OpenBabel::OBOp::DoOps(arg1,(std::map< std::string,std::string > const *)arg2); 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 int SWIGSTDCALL CSharp_SETWORD_get() { int jresult ; int result; result = (int) 32; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_WORDROLL_get() { int jresult ; int result; result = (int) 5; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_WORDMASK_get() { int jresult ; int result; result = (int) 31; jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_STARTWORDS_get() { int jresult ; int result; result = (int) 10; jresult = result; 
  return jresult; }
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 int SWIGSTDCALL CSharp_OBBitVec_GetSize(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)->GetSize(); jresult = 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_OBMolAtomIter__SWIG_0() { void * jresult ; OpenBabel::OBMolAtomIter *result = 0 ;
  result = (OpenBabel::OBMolAtomIter *)new OpenBabel::OBMolAtomIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBMolAtomIter___deref__(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_OBMolAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  {
    OpenBabel::OBAtom &_result_ref = ((OpenBabel::OBMolAtomIter const *)arg1)->operator *();
    result = (OpenBabel::OBAtom *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetHyb(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; short arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (short)jarg2;  (*arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double arg2 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (double)jarg2;  (*arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (*arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetVector__SWIG_2(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double **arg2 = (double **) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (double **)jarg2;  (*arg1)->SetCoordPtr(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetPositiveStereo(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetNegativeStereo(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_UnsetStereo(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetInRing(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_SetChiral(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->SetChiral(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_ClearCoordPtr(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->ClearCoordPtr(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomIter_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (int)(*arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetAtomicNum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBMolAtomIter_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned short result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned short)(*arg1)->GetIsotope(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomIter_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (int)(*arg1)->GetSpinMultiplicity(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCoordinateIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetValence(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetImplicitValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHvyValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHeteroValence(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_x(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_y(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_z(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (double *)(*arg1)->GetCoordinate(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  { OpenBabel::vector3 &_result_ref = (*arg1)->GetVector();
    result = (OpenBabel::vector3 *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->GetPartialCharge(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  double arg3 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(*arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetNextAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (*arg1)->BeginBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (*arg1)->EndBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (double)(*arg1)->GetDistance(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (double)(*arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3;  result = (double)(*arg1)->GetAngle(arg2,arg3);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_NewResidue(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_DeleteResidue(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (*arg1)->AddBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (*arg1)->InsertBond(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->DeleteBond(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_ClearBond(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->SetHybAndGeom(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_ForceNoH(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_ForceImplH(void * jarg1) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  (*arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountFreeOxygens(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ImplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool arg2 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_ExplicitHydrogenCount__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingSize(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountRingBonds(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->SmallestBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomIter_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (double)(*arg1)->AverageBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRingSize(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsConnected(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneThree(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneFour(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPhosphateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNonPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasChiralitySpecified(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(*arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasAlphaBetaUnsat(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasBondOfOrder(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasBondOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomIter_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (int)(*arg1)->CountBondsOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(*arg1)->MatchesSMARTS((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomIter *)jarg1;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomIter *)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_OBMolAtomIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomIter *arg1 = (OpenBabel::OBMolAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomDFSIter__SWIG_0() { void * jresult ; OpenBabel::OBMolAtomDFSIter *result = 0 ;
  result = (OpenBabel::OBMolAtomDFSIter *)new OpenBabel::OBMolAtomDFSIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomDFSIter__SWIG_1(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_2(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_4(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 void * SWIGSTDCALL CSharp_OBMolAtomDFSIter___deref__(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___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  {
    OpenBabel::OBAtom &_result_ref = ((OpenBabel::OBMolAtomDFSIter const *)arg1)->operator *();
    result = (OpenBabel::OBAtom *) &_result_ref; }  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_OBMolAtomDFSIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetHyb(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; short arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (short)jarg2;  (*arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (double)jarg2;  (*arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (*arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetVector__SWIG_2(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double **arg2 = (double **) 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (double **)jarg2;  (*arg1)->SetCoordPtr(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetPositiveStereo(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetNegativeStereo(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_UnsetStereo(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetInRing(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetChiral(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->SetChiral(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_ClearCoordPtr(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->ClearCoordPtr(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (int)(*arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetAtomicNum(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned short result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned short)(*arg1)->GetIsotope(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (int)(*arg1)->GetSpinMultiplicity(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetCoordinateIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetImplicitValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHvyValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHeteroValence(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_x(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_y(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_z(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double *)(*arg1)->GetCoordinate(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  { OpenBabel::vector3 &_result_ref = (*arg1)->GetVector();
    result = (OpenBabel::vector3 *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->GetPartialCharge(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  double arg3 ; bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(*arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetNextAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  result = (*arg1)->BeginBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  result = (*arg1)->EndBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  result = (double)(*arg1)->GetDistance(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (double)(*arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_NewResidue(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_DeleteResidue(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (*arg1)->AddBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (*arg1)->InsertBond(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->DeleteBond(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_ClearBond(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->SetHybAndGeom(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_ForceNoH(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_ForceImplH(void * jarg1) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  (*arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->CountFreeOxygens(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->ImplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool arg2 ;
  unsigned int result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_ExplicitHydrogenCount__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingSize(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->CountRingBonds(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->SmallestBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomDFSIter_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (double)(*arg1)->AverageBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRingSize(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsConnected(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneThree(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneFour(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsPhosphateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsNonPolarHydrogen(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasChiralitySpecified(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(*arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasAlphaBetaUnsat(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasBondOfOrder(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(*arg1)->HasBondOfOrder(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomDFSIter_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (int)(*arg1)->CountBondsOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (char *)jarg2; 
  result = (bool)(*arg1)->MatchesSMARTS((char const *)arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomDFSIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; std::string *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomDFSIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomDFSIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  OpenBabel::OBGenericData *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1;  {
    std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)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_OBMolAtomDFSIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomDFSIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomDFSIter *arg1 = (OpenBabel::OBMolAtomDFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomDFSIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomBFSIter__SWIG_0() { void * jresult ; OpenBabel::OBMolAtomBFSIter *result = 0 ;
  result = (OpenBabel::OBMolAtomBFSIter *)new OpenBabel::OBMolAtomBFSIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAtomBFSIter__SWIG_1(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_2(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_4(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 void * SWIGSTDCALL CSharp_OBMolAtomBFSIter___deref__(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 void * SWIGSTDCALL CSharp_OBMolAtomBFSIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  {
    OpenBabel::OBAtom &_result_ref = ((OpenBabel::OBMolAtomBFSIter const *)arg1)->operator *();
    result = (OpenBabel::OBAtom *) &_result_ref; }  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_OBMolAtomBFSIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetHyb(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; short arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (short)jarg2;  (*arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (double)jarg2;  (*arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (*arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetVector__SWIG_2(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double **arg2 = (double **) 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (double **)jarg2;  (*arg1)->SetCoordPtr(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetPositiveStereo(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetNegativeStereo(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_UnsetStereo(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetInRing(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetChiral(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->SetChiral(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_ClearCoordPtr(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->ClearCoordPtr(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (int)(*arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetAtomicNum(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned short result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned short)(*arg1)->GetIsotope(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (int)(*arg1)->GetSpinMultiplicity(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetCoordinateIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetImplicitValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHvyValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->GetHeteroValence(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_x(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_y(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_z(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double *)(*arg1)->GetCoordinate(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  { OpenBabel::vector3 &_result_ref = (*arg1)->GetVector();
    result = (OpenBabel::vector3 *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->GetPartialCharge(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  double arg3 ; bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(*arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetNextAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  result = (*arg1)->BeginBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  result = (*arg1)->EndBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  result = (double)(*arg1)->GetDistance(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (double)(*arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_NewResidue(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_DeleteResidue(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (*arg1)->AddBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (*arg1)->InsertBond(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->DeleteBond(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_ClearBond(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->SetHybAndGeom(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_ForceNoH(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_ForceImplH(void * jarg1) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  (*arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->CountFreeOxygens(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->ImplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool arg2 ;
  unsigned int result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_ExplicitHydrogenCount__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingSize(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->CountRingBonds(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->SmallestBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolAtomBFSIter_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; double result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (double)(*arg1)->AverageBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRingSize(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsConnected(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneThree(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneFour(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsPhosphateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsNonPolarHydrogen(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasChiralitySpecified(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(*arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasAlphaBetaUnsat(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasBondOfOrder(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(*arg1)->HasBondOfOrder(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolAtomBFSIter_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (int)(*arg1)->CountBondsOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (char *)jarg2; 
  result = (bool)(*arg1)->MatchesSMARTS((char const *)arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolAtomBFSIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; std::string *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolAtomBFSIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolAtomBFSIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  OpenBabel::OBGenericData *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1;  {
    std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)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_OBMolAtomBFSIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolAtomBFSIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolAtomBFSIter *arg1 = (OpenBabel::OBMolAtomBFSIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolAtomBFSIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondIter__SWIG_0() { void * jresult ; OpenBabel::OBMolBondIter *result = 0 ;
  result = (OpenBabel::OBMolBondIter *)new OpenBabel::OBMolBondIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolBondIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBMolBondIter___deref__(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_OBMolBondIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  {
    OpenBabel::OBBond &_result_ref = ((OpenBabel::OBMolBondIter const *)arg1)->operator *();
    result = (OpenBabel::OBBond *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetBO(void * jarg1, int jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetBO(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetBondOrder(void * jarg1, int jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetBondOrder(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetBegin(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->SetBegin(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetEnd(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->SetEnd(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetLength__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double arg3 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (double)jarg3; 
  (*arg1)->SetLength(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetLength__SWIG_1(void * jarg1, double jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; double arg2 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (double)jarg2;  (*arg1)->SetLength(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_Set(void * jarg1, int jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; int arg2 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ; int arg5 ; int arg6 ;
  arg1 = (OpenBabel::OBMolBondIter *)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_OBMolBondIter_SetKSingle(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetKSingle(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetKDouble(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetKDouble(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetKTriple(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetKTriple(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetAromatic(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetHash(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetWedge(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetUp(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetDown(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetInRing(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_SetClosure(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->SetClosure(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetHash(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetWedge(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetUp(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetDown(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_UnsetKekule(void * jarg1) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  (*arg1)->UnsetKekule(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetBO(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBO(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetBondOrder(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBondOrder(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetFlags(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetFlags(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetBeginAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBeginAtomIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetEndAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetEndAtomIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetBeginAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetBeginAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetEndAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetEndAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBAtom *)(*arg1)->GetNbrAtom(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolBondIter_GetEquibLength(void * jarg1) { double jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; double result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (double)(*arg1)->GetEquibLength(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBMolBondIter_GetLength(void * jarg1) { double jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; double result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (double)(*arg1)->GetLength(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_GetNbrAtomIdx(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int result; arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (unsigned int)(*arg1)->GetNbrAtomIdx(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsRotor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsRotor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsPrimaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsPrimaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsSecondaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsSecondaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsEster(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsEster(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsCarbonyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsCarbonyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsKSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsKDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsKTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsClosure(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsClosure(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsUp(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsUp(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsDown(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDown(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsWedge(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsWedge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsHash(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsHash(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_IsDoubleBondGeometry(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDoubleBondGeometry(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolBondIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)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_OBMolBondIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBMolBondIter *)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_OBMolBondIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolBondIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolBondIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBMolBondIter *)jarg1;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolBondIter *)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_OBMolBondIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBMolBondIter *)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_OBMolBondIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolBondIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBMolBondIter *arg1 = (OpenBabel::OBMolBondIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBMolBondIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomAtomIter__SWIG_0() { void * jresult ; OpenBabel::OBAtomAtomIter *result = 0 ;
  result = (OpenBabel::OBAtomAtomIter *)new OpenBabel::OBAtomAtomIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomAtomIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBAtomAtomIter___deref__(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_OBAtomAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  {
    OpenBabel::OBAtom &_result_ref = ((OpenBabel::OBAtomAtomIter const *)arg1)->operator *();
    result = (OpenBabel::OBAtom *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetHyb(void * jarg1, int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; short arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (short)jarg2;  (*arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double arg2 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (double)jarg2;  (*arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (*arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetVector__SWIG_2(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double **arg2 = (double **) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (double **)jarg2;  (*arg1)->SetCoordPtr(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetAromatic(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetClockwiseStereo(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetPositiveStereo(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetNegativeStereo(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_UnsetStereo(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetInRing(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_SetChiral(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->SetChiral(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_ClearCoordPtr(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->ClearCoordPtr(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtomAtomIter_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (int)(*arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetAtomicNum(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBAtomAtomIter_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned short result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned short)(*arg1)->GetIsotope(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtomAtomIter_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (int)(*arg1)->GetSpinMultiplicity(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCoordinateIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetValence(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetImplicitValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHvyValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHeteroValence(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBAtomAtomIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_x(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_y(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_z(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (double *)(*arg1)->GetCoordinate(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  { OpenBabel::vector3 &_result_ref = (*arg1)->GetVector();
    result = (OpenBabel::vector3 *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->GetPartialCharge(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  double arg3 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(*arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetNextAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (*arg1)->BeginBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (*arg1)->EndBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (double)(*arg1)->GetDistance(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (double)(*arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_NewResidue(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_DeleteResidue(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (*arg1)->AddBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (*arg1)->InsertBond(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->DeleteBond(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_ClearBond(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->SetHybAndGeom(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_ForceNoH(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_ForceImplH(void * jarg1) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  (*arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountFreeOxygens(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ImplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool arg2 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_ExplicitHydrogenCount__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingSize(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountRingBonds(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->SmallestBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomAtomIter_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (double)(*arg1)->AverageBondAngle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRingSize(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsConnected(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneThree(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneFour(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPhosphateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNonPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasChiralitySpecified(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(*arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasAlphaBetaUnsat(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasBondOfOrder(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasBondOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBAtomAtomIter_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (int)(*arg1)->CountBondsOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (char *)jarg2;  result = (bool)(*arg1)->MatchesSMARTS((char const *)arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBAtomAtomIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; std::string *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomAtomIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomAtomIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBAtomAtomIter *)jarg1;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBAtomAtomIter *)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_OBAtomAtomIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomAtomIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomAtomIter *arg1 = (OpenBabel::OBAtomAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBAtomAtomIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomBondIter__SWIG_0() { void * jresult ; OpenBabel::OBAtomBondIter *result = 0 ;
  result = (OpenBabel::OBAtomBondIter *)new OpenBabel::OBAtomBondIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBAtomBondIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBAtomBondIter___deref__(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_OBAtomBondIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBBond *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  {
    OpenBabel::OBBond &_result_ref = ((OpenBabel::OBAtomBondIter const *)arg1)->operator *();
    result = (OpenBabel::OBBond *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool arg2 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetBO(void * jarg1, int jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetBO(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetBondOrder(void * jarg1, int jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; int arg2 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (int)jarg2;  (*arg1)->SetBondOrder(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetBegin(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->SetBegin(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetEnd(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->SetEnd(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetLength__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double arg3 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (double)jarg3; 
  (*arg1)->SetLength(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetLength__SWIG_1(void * jarg1, double jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; double arg2 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (double)jarg2;  (*arg1)->SetLength(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_Set(void * jarg1, int jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; int arg2 ;
  OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg4 = (OpenBabel::OBAtom *) 0 ; int arg5 ; int arg6 ;
  arg1 = (OpenBabel::OBAtomBondIter *)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_OBAtomBondIter_SetKSingle(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetKSingle(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetKDouble(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetKDouble(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetKTriple(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetKTriple(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetAromatic(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetHash(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetWedge(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetUp(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetDown(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetInRing(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_SetClosure(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->SetClosure(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetHash(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetHash(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetWedge(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetWedge(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetUp(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetUp(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetDown(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetDown(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_UnsetKekule(void * jarg1) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  (*arg1)->UnsetKekule(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetBO(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBO(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetBondOrder(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBondOrder(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetFlags(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetFlags(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetBeginAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetBeginAtomIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetEndAtomIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->GetEndAtomIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetBeginAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetBeginAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetEndAtom__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetEndAtom(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBAtom *)(*arg1)->GetNbrAtom(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomBondIter_GetEquibLength(void * jarg1) { double jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (double)(*arg1)->GetEquibLength(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBAtomBondIter_GetLength(void * jarg1) { double jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; double result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (double)(*arg1)->GetLength(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_GetNbrAtomIdx(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (unsigned int)(*arg1)->GetNbrAtomIdx(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsRotor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsRotor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsPrimaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsPrimaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsSecondaryAmide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsSecondaryAmide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsEster(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsEster(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsCarbonyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsCarbonyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsKSingle(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKSingle(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsKDouble(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKDouble(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsKTriple(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsKTriple(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsClosure(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsClosure(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsUp(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsUp(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsDown(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDown(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsWedge(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsWedge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsHash(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsHash(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_IsDoubleBondGeometry(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->IsDoubleBondGeometry(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; bool result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBAtomBondIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)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_OBAtomBondIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; std::string *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBAtomBondIter *)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_OBAtomBondIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBAtomBondIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBAtomBondIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBAtomBondIter *)jarg1;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBAtomBondIter *)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_OBAtomBondIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBAtomBondIter *)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_OBAtomBondIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBAtomBondIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBAtomBondIter *arg1 = (OpenBabel::OBAtomBondIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBAtomBondIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueIter__SWIG_0() { void * jresult ; OpenBabel::OBResidueIter *result = 0 ;
  result = (OpenBabel::OBResidueIter *)new OpenBabel::OBResidueIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBResidueIter___deref__(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_OBResidueIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  {
    OpenBabel::OBResidue &_result_ref = ((OpenBabel::OBResidueIter const *)arg1)->operator *();
    result = (OpenBabel::OBResidue *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_AddAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->AddAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_InsertAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->InsertAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_RemoveAtom(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->RemoveAtom(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetName(void * jarg1, char * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_SetNum__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetNum__SWIG_1(void * jarg1, char * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::string arg2 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); return ; } 
  (&arg2)->assign(jarg2);  (*arg1)->SetNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetChain(void * jarg1, char jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; char arg2 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (char)jarg2;  (*arg1)->SetChain(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetChainNum(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetChainNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetIdx(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetAtomID(void * jarg1, void * jarg2, char * jarg3) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  std::string *arg3 = 0 ; arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_SetHetAtom(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool arg3 ; arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = jarg3 ? true : false; 
  (*arg1)->SetHetAtom(arg2,arg3); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_SetSerialNum(void * jarg1, void * jarg2, unsigned int jarg3) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int arg3 ; arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  arg3 = (unsigned int)jarg3;  (*arg1)->SetSerialNum(arg2,arg3); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueIter_GetName(void * jarg1) { char * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::string result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (*arg1)->GetName();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->GetNum(); jresult = result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueIter_GetNumString(void * jarg1) { char * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::string result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (*arg1)->GetNumString();
  jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetNumAtoms(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->GetNumAtoms(); jresult = result;  return jresult; }
SWIGEXPORT char SWIGSTDCALL CSharp_OBResidueIter_GetChain(void * jarg1) { char jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; char result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (char)(*arg1)->GetChain(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetChainNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->GetChainNum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetResKey(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->GetResKey(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBAtom * > > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->GetAtoms();
  jresult = new std::vector< OpenBabel::OBAtom * >((const std::vector< OpenBabel::OBAtom * > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetBonds__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; bool arg2 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * > > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = jarg2 ? true : false;  result = (*arg1)->GetBonds(arg2);
  jresult = new std::vector< OpenBabel::OBBond * >((const std::vector< OpenBabel::OBBond * > &)result);  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetBonds__SWIG_1(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * > > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->GetBonds();
  jresult = new std::vector< OpenBabel::OBBond * >((const std::vector< OpenBabel::OBBond * > &)result);  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueIter_GetAtomID(void * jarg1, void * jarg2) { char * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  std::string result; arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (*arg1)->GetAtomID(arg2); jresult = SWIG_csharp_string_callback((&result)->c_str());  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetSerialNum(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  unsigned int result; arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (unsigned int)(*arg1)->GetSerialNum(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetAminoAcidProperty(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->GetAminoAcidProperty(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetAtomProperty(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ; OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; int arg3 ; bool result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (int)jarg3;  result = (bool)(*arg1)->GetAtomProperty(arg2,arg3); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_GetResidueProperty(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->GetResidueProperty(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_IsHetAtom(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsHetAtom(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_IsResidueType(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsResidueType(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_BeginAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->BeginAtoms(); jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_EndAtoms(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBAtom * >::iterator > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->EndAtoms(); jresult = new OpenBabel::OBAtomIterator((const OpenBabel::OBAtomIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_BeginAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::vector< OpenBabel::OBAtom * >::iterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_NextAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::vector< OpenBabel::OBAtom * >::iterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (std::vector< OpenBabel::OBAtom * >::iterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< OpenBabel::OBAtom * >::iterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; bool result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (bool)(*arg1)->HasData(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::string *arg2 = 0 ; bool result;
  arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ; OpenBabel::OBGenericData *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; std::vector< OpenBabel::OBGenericData * > *result = 0 ;
  arg1 = (OpenBabel::OBResidueIter *)jarg1;  { std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBResidueIter *)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_OBResidueIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueIter *arg1 = (OpenBabel::OBResidueIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBResidueIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueAtomIter__SWIG_0() { void * jresult ;
  OpenBabel::OBResidueAtomIter *result = 0 ; result = (OpenBabel::OBResidueAtomIter *)new OpenBabel::OBResidueAtomIter();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBResidueAtomIter__SWIG_1(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_2(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 void * SWIGSTDCALL CSharp_OBResidueAtomIter___deref__(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_OBResidueAtomIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  {
    OpenBabel::OBAtom &_result_ref = ((OpenBabel::OBResidueAtomIter const *)arg1)->operator *();
    result = (OpenBabel::OBAtom *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_Visit_set(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = jarg2 ? true : false;  if (arg1) (*arg1)->Visit = arg2; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_Visit_get(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool) ((*arg1)->Visit); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_Duplicate(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  (*arg1)->Duplicate(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetIdx(void * jarg1, int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetIdx(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetHyb(void * jarg1, int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetHyb(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetAtomicNum(void * jarg1, int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetAtomicNum(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetIsotope(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->SetIsotope(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetImplicitValence(void * jarg1, int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetImplicitValence(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_IncrementImplicitValence(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->IncrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_DecrementImplicitValence(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->DecrementImplicitValence(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetFormalCharge(void * jarg1, int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  (*arg1)->SetFormalCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetSpinMultiplicity(void * jarg1, short jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; short arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (short)jarg2;  (*arg1)->SetSpinMultiplicity(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType((char const *)arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetPartialCharge(void * jarg1, double jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (double)jarg2;  (*arg1)->SetPartialCharge(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetVector__SWIG_0(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_SetVector__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double arg2 ; double arg3 ; double arg4 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (double)jarg2;  arg3 = (double)jarg3;  arg4 = (double)jarg4; 
  (*arg1)->SetVector(arg2,arg3,arg4); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetVector__SWIG_2(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetVector(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetCoordPtr(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double **arg2 = (double **) 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (double **)jarg2;  (*arg1)->SetCoordPtr(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->SetResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetAromatic(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_UnsetAromatic(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->UnsetAromatic(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetClockwiseStereo(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetAntiClockwiseStereo(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetAntiClockwiseStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetPositiveStereo(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetPositiveStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetNegativeStereo(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetNegativeStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_UnsetStereo(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->UnsetStereo(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetInRing(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetInRing(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_SetChiral(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->SetChiral(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_ClearCoordPtr(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->ClearCoordPtr(); }
SWIGEXPORT int SWIGSTDCALL CSharp_OBResidueAtomIter_GetFormalCharge(void * jarg1) { int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (int)(*arg1)->GetFormalCharge(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetAtomicNum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetAtomicNum(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_OBResidueAtomIter_GetIsotope(void * jarg1) { unsigned short jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned short result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned short)(*arg1)->GetIsotope(); jresult = result; 
  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBResidueAtomIter_GetSpinMultiplicity(void * jarg1) { int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (int)(*arg1)->GetSpinMultiplicity(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetAtomicMass(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetAtomicMass(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetExactMass(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetExactMass(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetCoordinateIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCoordinateIdx(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetCIdx(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetCIdx(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetHyb(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHyb(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetImplicitValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetImplicitValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetHvyValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHvyValence(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetHeteroValence(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->GetHeteroValence(); jresult = result; 
  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueAtomIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetX(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetX(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetY(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetY(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetZ(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetZ(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_x(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->x(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_y(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->y(); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_z(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->z(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetCoordinate(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double *)(*arg1)->GetCoordinate(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetVector__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::vector3 *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  { OpenBabel::vector3 &_result_ref = (*arg1)->GetVector();
    result = (OpenBabel::vector3 *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetPartialCharge(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->GetPartialCharge(); jresult = result; 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetResidue__SWIG_0(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetResidue__SWIG_1(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool arg2 ; OpenBabel::OBResidue *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (OpenBabel::OBResidue *)(*arg1)->GetResidue(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_GetNewBondVector(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::vector3 *arg2 = 0 ; double arg3 ; bool result; arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_GetBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (OpenBabel::OBBond *)(*arg1)->GetBond(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetNextAtom(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (OpenBabel::OBAtom *)(*arg1)->GetNextAtom();
  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_BeginBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  result = (*arg1)->BeginBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_EndBonds(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBBond * >::iterator > result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  result = (*arg1)->EndBonds(); jresult = new OpenBabel::OBBondIterator((const OpenBabel::OBBondIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_BeginBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->BeginBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_NextBond(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBBond *)(*arg1)->NextBond(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_BeginNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->BeginNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_NextNbrAtom(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBAtom *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBondIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return 0; }   result = (OpenBabel::OBAtom *)(*arg1)->NextNbrAtom(*arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetDistance__SWIG_0(void * jarg1, int jarg2) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (double)(*arg1)->GetDistance(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetDistance__SWIG_1(void * jarg1, void * jarg2) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  double result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (double)(*arg1)->GetDistance(arg2); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetAngle__SWIG_0(void * jarg1, int jarg2, int jarg3) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ; int arg3 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  arg3 = (int)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_GetAngle__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ; OpenBabel::OBAtom *arg3 = (OpenBabel::OBAtom *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2;  arg3 = (OpenBabel::OBAtom *)jarg3; 
  result = (double)(*arg1)->GetAngle(arg2,arg3); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_NewResidue(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->NewResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_AddResidue(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBResidue *arg2 = (OpenBabel::OBResidue *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBResidue *)jarg2;  (*arg1)->AddResidue(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_DeleteResidue(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->DeleteResidue(); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_AddBond(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2;  (*arg1)->AddBond(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_InsertBond(void * jarg1, void * jarg2, void * jarg3) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBondIterator *arg2 = 0 ;
  OpenBabel::OBBond *arg3 = (OpenBabel::OBBond *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBBondIterator *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBondIterator & type is null", 0);
    return ; }   arg3 = (OpenBabel::OBBond *)jarg3;  (*arg1)->InsertBond(*arg2,arg3); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_DeleteBond(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->DeleteBond(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_ClearBond(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->ClearBond(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HtoMethyl(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HtoMethyl(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_SetHybAndGeom(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->SetHybAndGeom(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_ForceNoH(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->ForceNoH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasNoHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasNoHForced(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_ForceImplH(void * jarg1) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  (*arg1)->ForceImplH(); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasImplHForced(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasImplHForced(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_CountFreeOxygens(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountFreeOxygens(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_ImplicitHydrogenCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ImplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_ExplicitHydrogenCount__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool arg2 ;
  unsigned int result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = jarg2 ? true : false; 
  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_ExplicitHydrogenCount__SWIG_1(void * jarg1) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->ExplicitHydrogenCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_MemberOfRingCount(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingCount(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_MemberOfRingSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->MemberOfRingSize(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_CountRingBonds(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->CountRingBonds(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_SmallestBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->SmallestBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT double SWIGSTDCALL CSharp_OBResidueAtomIter_AverageBondAngle(void * jarg1) { double jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; double result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (double)(*arg1)->AverageBondAngle(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_BOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->BOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_KBOSum(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->KBOSum(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasResidue(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasResidue(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsCarbon(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsCarbon(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsSulfur(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsSulfur(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsPhosphorus(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsPhosphorus(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsInRing(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsInRing(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsInRingSize(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRingSize(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsHeteroatom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsHeteroatom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsNotCorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsNotCorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsConnected(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsConnected(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsOneThree(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneThree(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsOneFour(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsOneFour(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsCarboxylOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsCarboxylOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsPhosphateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsPhosphateOxygen(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsSulfateOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsSulfateOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsNitroOxygen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsNitroOxygen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsAmideNitrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsAmideNitrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsPolarHydrogen(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsNonPolarHydrogen(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsNonPolarHydrogen(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsAromaticNOxide(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsAromaticNOxide(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsChiral(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsChiral(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsAxial(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsAxial(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsAntiClockwise(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsAntiClockwise(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsPositiveStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsPositiveStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsNegativeStereo(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsNegativeStereo(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasChiralitySpecified(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasChiralitySpecified(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasChiralVolume(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasChiralVolume(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsHbondAcceptor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsHbondAcceptor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsHbondDonor(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonor(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_IsHbondDonorH(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->IsHbondDonorH(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasAlphaBetaUnsat__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool arg2 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = jarg2 ? true : false;  result = (bool)(*arg1)->HasAlphaBetaUnsat(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasAlphaBetaUnsat__SWIG_1(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasAlphaBetaUnsat(); jresult = result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasBondOfOrder(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(*arg1)->HasBondOfOrder(arg2); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBResidueAtomIter_CountBondsOfOrder(void * jarg1, unsigned int jarg2) { int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ; int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  result = (int)(*arg1)->CountBondsOfOrder(arg2);
  jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasNonSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasNonSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasSingleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasSingleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasDoubleBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasDoubleBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasAromaticBond(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->HasAromaticBond(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_MatchesSMARTS(void * jarg1, char * jarg2) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; char *arg2 = (char *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (char *)jarg2; 
  result = (bool)(*arg1)->MatchesSMARTS((char const *)arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_Clear(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; bool result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (bool)(*arg1)->Clear(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_DoTransformations(void * jarg1, void * jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; OpenBabel::OBBase *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (std::map< std::string,std::string > *)jarg2; 
  result = (OpenBabel::OBBase *)(*arg1)->DoTransformations((std::map< std::string,std::string > const *)arg2);
  jresult = (void *)result;  return jresult; }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBResidueAtomIter_ClassDescription(void * jarg1) { char * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (char *)(*arg1)->ClassDescription();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_HasData__SWIG_2(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (bool)(*arg1)->HasData(arg2); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_DeleteData__SWIG_0(void * jarg1, unsigned int jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_DeleteData__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->DeleteData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_DeleteData__SWIG_2(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  std::vector< OpenBabel::OBGenericData * > *arg2 = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_DeleteData__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ; OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; std::string *arg2 = 0 ;
  bool result; arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_SetData(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->SetData(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBResidueAtomIter_CloneData(void * jarg1, void * jarg2) {
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  OpenBabel::OBGenericData *arg2 = (OpenBabel::OBGenericData *) 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  arg2 = (OpenBabel::OBGenericData *)jarg2;  (*arg1)->CloneData(arg2); }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBResidueAtomIter_DataSize(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  result = (unsigned int)(*arg1)->DataSize(); jresult = result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetData__SWIG_0(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  OpenBabel::OBGenericData *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  arg2 = (unsigned int)jarg2; 
  result = (OpenBabel::OBGenericData *)(*arg1)->GetData(arg2); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetData__SWIG_3(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  std::vector< OpenBabel::OBGenericData * > *result = 0 ; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1;  {
    std::vector< OpenBabel::OBGenericData * > &_result_ref = (*arg1)->GetData();
    result = (std::vector< OpenBabel::OBGenericData * > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_GetData__SWIG_4(void * jarg1, int jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; OpenBabel::DataOrigin arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_GetAllData(void * jarg1, unsigned int jarg2) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ; unsigned int arg2 ;
  std::vector< OpenBabel::OBGenericData * > result; arg1 = (OpenBabel::OBResidueAtomIter *)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_OBResidueAtomIter_BeginData(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  result = (*arg1)->BeginData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBResidueAtomIter_EndData(void * jarg1) { void * jresult ;
  OpenBabel::OBResidueAtomIter *arg1 = (OpenBabel::OBResidueAtomIter *) 0 ;
  SwigValueWrapper< std::vector< OpenBabel::OBGenericData * >::iterator > result; arg1 = (OpenBabel::OBResidueAtomIter *)jarg1; 
  result = (*arg1)->EndData(); jresult = new OpenBabel::OBDataIterator((const OpenBabel::OBDataIterator &)result); 
  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAngleIter__SWIG_0() { void * jresult ; OpenBabel::OBMolAngleIter *result = 0 ;
  result = (OpenBabel::OBMolAngleIter *)new OpenBabel::OBMolAngleIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolAngleIter__SWIG_1(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_2(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 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 * jresult ; OpenBabel::OBMolPairIter *result = 0 ;
  result = (OpenBabel::OBMolPairIter *)new OpenBabel::OBMolPairIter(); jresult = (void *)result;  return jresult; }
SWIGEXPORT void * SWIGSTDCALL CSharp_new_OBMolPairIter__SWIG_1(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_2(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 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___deref__(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 void * SWIGSTDCALL CSharp_OBMolRingIter___ref__(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBRing *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  {
    OpenBabel::OBRing &_result_ref = ((OpenBabel::OBMolRingIter const *)arg1)->operator *();
    result = (OpenBabel::OBRing *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolRingIter__path_set(void * jarg1, void * jarg2) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; std::vector< int > *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (std::vector< int > *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ; }   if (arg1) (*arg1)->_path = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolRingIter__path_get(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; std::vector< int > *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  { std::vector< int > const &_result_ref =  ((*arg1)->_path);
    result = (std::vector< int > *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolRingIter__pathset_set(void * jarg1, void * jarg2) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBBitVec *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (OpenBabel::OBBitVec *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OpenBabel::OBBitVec const & type is null", 0);
    return ; }   if (arg1) (*arg1)->_pathset = *arg2; }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolRingIter__pathset_get(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBBitVec *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  { OpenBabel::OBBitVec const &_result_ref =  ((*arg1)->_pathset);
    result = (OpenBabel::OBBitVec *) &_result_ref; }  jresult = (void *)result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolRingIter_Size(void * jarg1) { int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; int result; arg1 = (OpenBabel::OBMolRingIter *)jarg1; 
  result = (int)(*arg1)->Size(); jresult = result;  return jresult; }
SWIGEXPORT int SWIGSTDCALL CSharp_OBMolRingIter_PathSize(void * jarg1) { int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; int result; arg1 = (OpenBabel::OBMolRingIter *)jarg1; 
  result = (int)(*arg1)->PathSize(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_IsAromatic(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; bool result; arg1 = (OpenBabel::OBMolRingIter *)jarg1; 
  result = (bool)(*arg1)->IsAromatic(); jresult = result;  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolRingIter_SetType__SWIG_0(void * jarg1, char * jarg2) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; char *arg2 = (char *) 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (char *)jarg2;  (*arg1)->SetType(arg2); }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolRingIter_SetType__SWIG_1(void * jarg1, void * jarg2) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; std::string *arg2 = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (std::string *)jarg2; if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0); return ; }  
  (*arg1)->SetType(*arg2); }
SWIGEXPORT char * SWIGSTDCALL CSharp_OBMolRingIter_GetType(void * jarg1) { char * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; char *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  result = (char *)(*arg1)->GetType();
  jresult = SWIG_csharp_string_callback((const char *)result);  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_GetRootAtom(void * jarg1) { unsigned int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; unsigned int result;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  result = (unsigned int)(*arg1)->GetRootAtom(); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_IsMember__SWIG_0(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBAtom *arg2 = (OpenBabel::OBAtom *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (OpenBabel::OBAtom *)jarg2; 
  result = (bool)(*arg1)->IsMember(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_IsMember__SWIG_1(void * jarg1, void * jarg2) { unsigned int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBBond *arg2 = (OpenBabel::OBBond *) 0 ;
  bool result; arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (OpenBabel::OBBond *)jarg2; 
  result = (bool)(*arg1)->IsMember(arg2); jresult = result;  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_IsInRing(void * jarg1, int jarg2) { unsigned int jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; int arg2 ; bool result;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (int)jarg2;  result = (bool)(*arg1)->IsInRing(arg2); jresult = result; 
  return jresult; }
SWIGEXPORT void SWIGSTDCALL CSharp_OBMolRingIter_SetParent(void * jarg1, void * jarg2) {
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBMol *arg2 = (OpenBabel::OBMol *) 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  arg2 = (OpenBabel::OBMol *)jarg2;  (*arg1)->SetParent(arg2); }
SWIGEXPORT void * SWIGSTDCALL CSharp_OBMolRingIter_GetParent(void * jarg1) { void * jresult ;
  OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::OBMol *result = 0 ;
  arg1 = (OpenBabel::OBMolRingIter *)jarg1;  result = (OpenBabel::OBMol *)(*arg1)->GetParent(); jresult = (void *)result; 
  return jresult; }
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_OBMolRingIter_findCenterAndNormal(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ; OpenBabel::OBMolRingIter *arg1 = (OpenBabel::OBMolRingIter *) 0 ; OpenBabel::vector3 *arg2 = 0 ;
  OpenBabel::vector3 *arg3 = 0 ; OpenBabel::vector3 *arg4 = 0 ; bool result; arg1 = (OpenBabel::OBMolRingIter *)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 OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBElementTableUpcast(OpenBabel::OBElementTable *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBIsotopeTableUpcast(OpenBabel::OBIsotopeTable *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBTypeTableUpcast(OpenBabel::OBTypeTable *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBResidueDataUpcast(OpenBabel::OBResidueData *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBCommentDataUpcast(OpenBabel::OBCommentData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBExternalBondDataUpcast(OpenBabel::OBExternalBondData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBPairDataUpcast(OpenBabel::OBPairData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSetDataUpcast(OpenBabel::OBSetData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVirtualBondUpcast(OpenBabel::OBVirtualBond *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBRingDataUpcast(OpenBabel::OBRingData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBUnitCellUpcast(OpenBabel::OBUnitCell *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBConformerDataUpcast(OpenBabel::OBConformerData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSymmetryDataUpcast(OpenBabel::OBSymmetryData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBTorsionDataUpcast(OpenBabel::OBTorsionData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBAngleDataUpcast(OpenBabel::OBAngleData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBChiralDataUpcast(OpenBabel::OBChiralData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBSerialNumsUpcast(OpenBabel::OBSerialNums *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVibrationDataUpcast(OpenBabel::OBVibrationData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBRotationDataUpcast(OpenBabel::OBRotationData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBVectorDataUpcast(OpenBabel::OBVectorData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBMatrixDataUpcast(OpenBabel::OBMatrixData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBGridDataUpcast(OpenBabel::OBGridData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBAtomTyperUpcast(OpenBabel::OBAtomTyper *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBAromaticTyperUpcast(OpenBabel::OBAromaticTyper *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGlobalDataBase * SWIGSTDCALL CSharp_OBRingTyperUpcast(OpenBabel::OBRingTyper *objectRef) {
    return (OpenBabel::OBGlobalDataBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBFormatUpcast(OpenBabel::OBFormat *objectRef) {
    return (OpenBabel::OBPlugin *)objectRef;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBResidueUpcast(OpenBabel::OBResidue *objectRef) {
    return (OpenBabel::OBBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBAtomUpcast(OpenBabel::OBAtom *objectRef) {
    return (OpenBabel::OBBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBBondUpcast(OpenBabel::OBBond *objectRef) {
    return (OpenBabel::OBBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBBase * SWIGSTDCALL CSharp_OBMolUpcast(OpenBabel::OBMol *objectRef) {
    return (OpenBabel::OBBase *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_AliasDataUpcast(OpenBabel::AliasData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBGenericData * SWIGSTDCALL CSharp_OBAtomClassDataUpcast(OpenBabel::OBAtomClassData *objectRef) {
    return (OpenBabel::OBGenericData *)objectRef;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBFingerprintUpcast(OpenBabel::OBFingerprint *objectRef) {
    return (OpenBabel::OBPlugin *)objectRef;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBDescriptorUpcast(OpenBabel::OBDescriptor *objectRef) {
    return (OpenBabel::OBPlugin *)objectRef;
}

SWIGEXPORT OpenBabel::OBFFCalculation2 * SWIGSTDCALL CSharp_OBFFCalculation3Upcast(OpenBabel::OBFFCalculation3 *objectRef) {
    return (OpenBabel::OBFFCalculation2 *)objectRef;
}

SWIGEXPORT OpenBabel::OBFFCalculation3 * SWIGSTDCALL CSharp_OBFFCalculation4Upcast(OpenBabel::OBFFCalculation4 *objectRef) {
    return (OpenBabel::OBFFCalculation3 *)objectRef;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBForceFieldUpcast(OpenBabel::OBForceField *objectRef) {
    return (OpenBabel::OBPlugin *)objectRef;
}

SWIGEXPORT OpenBabel::OBPlugin * SWIGSTDCALL CSharp_OBOpUpcast(OpenBabel::OBOp *objectRef) {
    return (OpenBabel::OBPlugin *)objectRef;
}

#ifdef __cplusplus
}
#endif

