text: /* ----------------------------------------------------------------------------
   * This file was automatically generated by SWIG (http://www.swig.org).
   * Version 1.3.25
   * 
   * This file is not intended to be easily readable and contains a number of 
   * coding conventions designed to improve portability and efficiency. Do not make
   * changes to this file unless you know what you are doing--modify the SWIG 
   * interface file instead. 
   * ----------------------------------------------------------------------------- */
  
  #define SWIGPYTHON
  /***********************************************************************
   *
   *  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
  #  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__) || defined(__ICC)
  #   define SWIGUNUSED __attribute__ ((unused)) 
  # else
  #   define 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 for Windows DLLs */
  #ifndef SWIGEXPORT
  # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  #   if defined(STATIC_LINKED)
  #     define SWIGEXPORT
  #   else
  #     define SWIGEXPORT __declspec(dllexport)
  #   endif
  # else
  #   define SWIGEXPORT
  # endif
  #endif
  
  /* calling conventions for Windows */
  #ifndef SWIGSTDCALL
  # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  #   define SWIGSTDCALL __stdcall
  # else
  #   define SWIGSTDCALL
  # endif 
  #endif
  
  
  
  #include <Python.h>
  
  /***********************************************************************
   * swigrun.swg
   *
   *     This file contains generic CAPI SWIG runtime support for pointer
   *     type checking.
   *
   ************************************************************************/
  
  /* This should only be incremented when either the layout of swig_type_info changes,
     or for whatever reason, the runtime changes incompatibly */
  #define SWIG_RUNTIME_VERSION "2"
  
  /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
  #ifdef SWIG_TYPE_TABLE
  # define SWIG_QUOTE_STRING(x) #x
  # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
  # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
  #else
  # define SWIG_TYPE_TABLE_NAME
  #endif
  
  /*
    You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
    creating a static or dynamic library from the swig runtime code.
    In 99.9% of the cases, swig just needs to declare them as 'static'.
    
    But only do this if is strictly necessary, ie, if you have problems
    with your compiler or so.
  */
  
  #ifndef SWIGRUNTIME
  # define SWIGRUNTIME SWIGINTERN
  #endif
  
  #ifndef SWIGRUNTIMEINLINE
  # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
  #endif
  
  #include <string.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  typedef void *(*swig_converter_func)(void *);
  typedef struct swig_type_info *(*swig_dycast_func)(void **);
  
  /* Structure to store inforomation on one type */
  typedef struct swig_type_info {
    const char             *name;			/* mangled name of this type */
    const char             *str;			/* human readable name of this type */
    swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
    struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
    void                   *clientdata;		/* language specific type data */
  } swig_type_info;
  
  /* Structure to store a type and conversion function used for casting */
  typedef struct swig_cast_info {
    swig_type_info         *type;			/* pointer to type that is equivalent to this type */
    swig_converter_func     converter;		/* function to cast the void pointers */
    struct swig_cast_info  *next;			/* pointer to next cast in linked list */
    struct swig_cast_info  *prev;			/* pointer to the previous cast */
  } swig_cast_info;
  
  /* Structure used to store module information
   * Each module generates one structure like this, and the runtime collects
   * all of these structures and stores them in a circularly linked list.*/
  typedef struct swig_module_info {
    swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
    size_t                 size;		        /* Number of types in this module */
    struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
    swig_type_info         **type_initial;	/* Array of initially generated type structures */
    swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
    void                    *clientdata;		/* Language specific module data */
  } swig_module_info;
  
  
  /* 
    Compare two type names skipping the space characters, therefore
    "char*" == "char *" and "Class<int>" == "Class<int >", etc.
  
    Return 0 when the two name types are equivalent, as in
    strncmp, but skipping ' '.
  */
  SWIGRUNTIME int
  SWIG_TypeNameComp(const char *f1, const char *l1,
  		  const char *f2, const char *l2) {
    for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
      while ((*f1 == ' ') && (f1 != l1)) ++f1;
      while ((*f2 == ' ') && (f2 != l2)) ++f2;
      if (*f1 != *f2) return (int)(*f1 - *f2);
    }
    return (l1 - f1) - (l2 - f2);
  }
  
  /*
    Check type equivalence in a name list like <name1>|<name2>|...
    Return 0 if not equal, 1 if equal
  */
  SWIGRUNTIME int
  SWIG_TypeEquiv(const char *nb, const char *tb) {
    int equiv = 0;
    const char* te = tb + strlen(tb);
    const char* ne = nb;
    while (!equiv && *ne) {
      for (nb = ne; *ne; ++ne) {
        if (*ne == '|') break;
      }
      equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
      if (*ne) ++ne;
    }
    return equiv;
  }
  
  /*
    Check type equivalence in a name list like <name1>|<name2>|...
    Return 0 if equal, -1 if nb < tb, 1 if nb > tb
  */
  SWIGRUNTIME int
  SWIG_TypeCompare(const char *nb, const char *tb) {
    int equiv = 0;
    const char* te = tb + strlen(tb);
    const char* ne = nb;
    while (!equiv && *ne) {
      for (nb = ne; *ne; ++ne) {
        if (*ne == '|') break;
      }
      equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
      if (*ne) ++ne;
    }
    return equiv;
  }
  
  
  /* think of this as a c++ template<> or a scheme macro */
  #define SWIG_TypeCheck_Template(comparison, ty)         \
    if (ty) {                                             \
      swig_cast_info *iter = ty->cast;                    \
      while (iter) {                                      \
        if (comparison) {                                 \
          if (iter == ty->cast) return iter;              \
          /* Move iter to the top of the linked list */   \
          iter->prev->next = iter->next;                  \
          if (iter->next)                                 \
            iter->next->prev = iter->prev;                \
          iter->next = ty->cast;                          \
          iter->prev = 0;                                 \
          if (ty->cast) ty->cast->prev = iter;            \
          ty->cast = iter;                                \
          return iter;                                    \
        }                                                 \
        iter = iter->next;                                \
      }                                                   \
    }                                                     \
    return 0
  
  /*
    Check the typename
  */
  SWIGRUNTIME swig_cast_info *
  SWIG_TypeCheck(const char *c, swig_type_info *ty) {
    SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
  }
  
  /* Same as previous function, except strcmp is replaced with a pointer comparison */
  SWIGRUNTIME swig_cast_info *
  SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
    SWIG_TypeCheck_Template(iter->type == from, into);
  }
  
  /*
    Cast a pointer up an inheritance hierarchy
  */
  SWIGRUNTIMEINLINE void *
  SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
    return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
  }
  
  /* 
     Dynamic pointer casting. Down an inheritance hierarchy
  */
  SWIGRUNTIME swig_type_info *
  SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
    swig_type_info *lastty = ty;
    if (!ty || !ty->dcast) return ty;
    while (ty && (ty->dcast)) {
      ty = (*ty->dcast)(ptr);
      if (ty) lastty = ty;
    }
    return lastty;
  }
  
  /*
    Return the name associated with this type
  */
  SWIGRUNTIMEINLINE const char *
  SWIG_TypeName(const swig_type_info *ty) {
    return ty->name;
  }
  
  /*
    Return the pretty name associated with this type,
    that is an unmangled type name in a form presentable to the user.
  */
  SWIGRUNTIME const char *
  SWIG_TypePrettyName(const swig_type_info *type) {
    /* The "str" field contains the equivalent pretty names of the
       type, separated by vertical-bar characters.  We choose
       to print the last name, as it is often (?) the most
       specific. */
    if (type->str != NULL) {
      const char *last_name = type->str;
      const char *s;
      for (s = type->str; *s; s++)
        if (*s == '|') last_name = s+1;
      return last_name;
    }
    else
      return type->name;
  }
  
  /* 
     Set the clientdata field for a type
  */
  SWIGRUNTIME void
  SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
    if (!ti->clientdata) {
      swig_cast_info *cast = ti->cast;
      /* if (ti->clientdata == clientdata) return; */
      ti->clientdata = clientdata;
      
      while (cast) {
        if (!cast->converter)
  	SWIG_TypeClientData(cast->type, clientdata);
        cast = cast->next;
      }
    }
  }
  
  /*
    Search for a swig_type_info structure only by mangled name
    Search is a O(log #types)
    
    We start searching at module start, and finish searching when start == end.  
    Note: if start == end at the beginning of the function, we go all the way around
    the circular list.
  */
  SWIGRUNTIME swig_type_info *
  SWIG_MangledTypeQueryModule(swig_module_info *start, 
                              swig_module_info *end, 
  		            const char *name) {
    swig_module_info *iter = start;
    do {
      if (iter->size) {
        register size_t l = 0;
        register size_t r = iter->size - 1;
        do {
  	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
  	register size_t i = (l + r) >> 1; 
  	const char *iname = iter->types[i]->name;
  	if (iname) {
  	  register int compare = strcmp(name, iname);
  	  if (compare == 0) {	    
  	    return iter->types[i];
  	  } else if (compare < 0) {
  	    if (i) {
  	      r = i - 1;
  	    } else {
  	      break;
  	    }
  	  } else if (compare > 0) {
  	    l = i + 1;
  	  }
  	} else {
  	  break; /* should never happen */
  	}
        } while (l <= r);
      }
      iter = iter->next;
    } while (iter != end);
    return 0;
  }
  
  /*
    Search for a swig_type_info structure for either a mangled name or a human readable name.
    It first searches the mangled names of the types, which is a O(log #types)
    If a type is not found it then searches the human readable names, which is O(#types).
    
    We start searching at module start, and finish searching when start == end.  
    Note: if start == end at the beginning of the function, we go all the way around
    the circular list.
  */
  SWIGRUNTIME swig_type_info *
  SWIG_TypeQueryModule(swig_module_info *start, 
                       swig_module_info *end, 
  		     const char *name) {
    /* STEP 1: Search the name field using binary search */
    swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
    if (ret) {
      return ret;
    } else {
      /* STEP 2: If the type hasn't been found, do a complete search
         of the str field (the human readable name) */
      swig_module_info *iter = start;
      do {
        register size_t i = 0;
        for (; i < iter->size; ++i) {
  	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
  	  return iter->types[i];
        }
        iter = iter->next;
      } while (iter != end);
    }
    
    /* neither found a match */
    return 0;
  }
  
  
  /* 
     Pack binary data into a string
  */
  SWIGRUNTIME char *
  SWIG_PackData(char *c, void *ptr, size_t sz) {
    static const char hex[17] = "0123456789abcdef";
    register const unsigned char *u = (unsigned char *) ptr;
    register const unsigned char *eu =  u + sz;
    for (; u != eu; ++u) {
      register unsigned char uu = *u;
      *(c++) = hex[(uu & 0xf0) >> 4];
      *(c++) = hex[uu & 0xf];
    }
    return c;
  }
  
  /* 
     Unpack binary data from a string
  */
  SWIGRUNTIME const char *
  SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
    register unsigned char *u = (unsigned char *) ptr;
    register const unsigned char *eu = u + sz;
    for (; u != eu; ++u) {
      register char d = *(c++);
      register unsigned char uu = 0;
      if ((d >= '0') && (d <= '9'))
        uu = ((d - '0') << 4);
      else if ((d >= 'a') && (d <= 'f'))
        uu = ((d - ('a'-10)) << 4);
      else 
        return (char *) 0;
      d = *(c++);
      if ((d >= '0') && (d <= '9'))
        uu |= (d - '0');
      else if ((d >= 'a') && (d <= 'f'))
        uu |= (d - ('a'-10));
      else 
        return (char *) 0;
      *u = uu;
    }
    return c;
  }
  
  /* 
     Pack 'void *' into a string buffer.
  */
  SWIGRUNTIME char *
  SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
    char *r = buff;
    if ((2*sizeof(void *) + 2) > bsz) return 0;
    *(r++) = '_';
    r = SWIG_PackData(r,&ptr,sizeof(void *));
    if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
    strcpy(r,name);
    return buff;
  }
  
  SWIGRUNTIME const char *
  SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
    if (*c != '_') {
      if (strcmp(c,"NULL") == 0) {
        *ptr = (void *) 0;
        return name;
      } else {
        return 0;
      }
    }
    return SWIG_UnpackData(++c,ptr,sizeof(void *));
  }
  
  SWIGRUNTIME char *
  SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
    char *r = buff;
    size_t lname = (name ? strlen(name) : 0);
    if ((2*sz + 2 + lname) > bsz) return 0;
    *(r++) = '_';
    r = SWIG_PackData(r,ptr,sz);
    if (lname) {
      strncpy(r,name,lname+1);
    } else {
      *r = 0;
    }
    return buff;
  }
  
  SWIGRUNTIME const char *
  SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
    if (*c != '_') {
      if (strcmp(c,"NULL") == 0) {
        memset(ptr,0,sz);
        return name;
      } else {
        return 0;
      }
    }
    return SWIG_UnpackData(++c,ptr,sz);
  }
  
  #ifdef __cplusplus
  }
  #endif
  
  /* -----------------------------------------------------------------------------
   * SWIG API. Portion that goes into the runtime
   * ----------------------------------------------------------------------------- */
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /* -----------------------------------------------------------------------------
   * for internal method declarations
   * ----------------------------------------------------------------------------- */
  
  #ifndef SWIGINTERN
  #  define SWIGINTERN static SWIGUNUSED
  #endif
  
  #ifndef SWIGINTERNINLINE
  #  define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  #endif
  
  /*
    Exception handling in wrappers
  */
  #define SWIG_fail                goto fail
  #define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
  #define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
  #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
  #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
  #define SWIG_null_ref(type)       SWIG_Python_NullRef(type)
  
  /*
    Contract support
  */
  #define SWIG_contract_assert(expr, msg) \
   if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
  
  /* -----------------------------------------------------------------------------
   * Constant declarations
   * ----------------------------------------------------------------------------- */
  
  /* Constant Types */
  #define SWIG_PY_INT     1
  #define SWIG_PY_FLOAT   2
  #define SWIG_PY_STRING  3
  #define SWIG_PY_POINTER 4
  #define SWIG_PY_BINARY  5
  
  /* Constant information structure */
  typedef struct swig_const_info {
      int type;
      char *name;
      long lvalue;
      double dvalue;
      void   *pvalue;
      swig_type_info **ptype;
  } swig_const_info;
  
  
  /* -----------------------------------------------------------------------------
   * Alloc. memory flags
   * ----------------------------------------------------------------------------- */
  #define SWIG_OLDOBJ  1
  #define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
  #define SWIG_PYSTR   SWIG_NEWOBJ + 1
  
  #ifdef __cplusplus
  }
  #endif
  
  
  /***********************************************************************
   * pyrun.swg
   *
   *     This file contains the runtime support for Python modules
   *     and includes code for managing global variables and pointer
   *     type checking.
   *
   * Author : David Beazley (beazley@cs.uchicago.edu)
   ************************************************************************/
  
  /* Common SWIG API */
  #define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
  #define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
  #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
   
  
  /* Python-specific SWIG API */
  #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
  #define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
  
  /* Runtime API */
  #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
  #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
  
  /* -----------------------------------------------------------------------------
   * Pointer declarations
   * ----------------------------------------------------------------------------- */
  /*
    Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
    C/C++ pointers in the python side. Very useful for debugging, but
    not always safe.
  */
  #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
  #  define SWIG_COBJECT_TYPES
  #endif
  
  /* Flags for pointer conversion */
  #define SWIG_POINTER_EXCEPTION     0x1
  #define SWIG_POINTER_DISOWN        0x2
  
  
  /* Add PyOS_snprintf for old Pythons */
  #if PY_VERSION_HEX < 0x02020000
  #define PyOS_snprintf snprintf
  #endif
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /* -----------------------------------------------------------------------------
   * Create a new pointer string 
   * ----------------------------------------------------------------------------- */
  #ifndef SWIG_BUFFER_SIZE
  #define SWIG_BUFFER_SIZE 1024
  #endif
  
  #if defined(SWIG_COBJECT_TYPES)
  #if !defined(SWIG_COBJECT_PYTHON)
  /* -----------------------------------------------------------------------------
   * Implements a simple Swig Object type, and use it instead of PyCObject
   * ----------------------------------------------------------------------------- */
  
  typedef struct {
    PyObject_HEAD
    void *ptr;
    const char *desc;
  } PySwigObject;
  
  /* Declarations for objects of type PySwigObject */
  
  SWIGRUNTIME int
  PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
  {
    char result[SWIG_BUFFER_SIZE];
    flags = flags;
    if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
      fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
      return 0; 
    } else {
      return 1; 
    }
  }
    
  SWIGRUNTIME PyObject *
  PySwigObject_repr(PySwigObject *v)
  {
    char result[SWIG_BUFFER_SIZE];
    return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
      PyString_FromFormat("<Swig Object at %s>", result) : 0;
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_str(PySwigObject *v)
  {
    char result[SWIG_BUFFER_SIZE];
    return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
      PyString_FromString(result) : 0;
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_long(PySwigObject *v)
  {
    return PyLong_FromVoidPtr(v->ptr);
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_format(const char* fmt, PySwigObject *v)
  {
    PyObject *res = NULL;
    PyObject *args = PyTuple_New(1);
    if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
      PyObject *ofmt = PyString_FromString(fmt);
      if (ofmt) {
        res = PyString_Format(ofmt,args);
        Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }  
    return res;
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_oct(PySwigObject *v)
  {
    return PySwigObject_format("%o",v);
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_hex(PySwigObject *v)
  {
    return PySwigObject_format("%x",v);
  }
  
  SWIGRUNTIME int
  PySwigObject_compare(PySwigObject *v, PySwigObject *w)
  {
    int c = strcmp(v->desc, w->desc);
    if (c) {
      return (c > 0) ? 1 : -1;
    } else {
      void *i = v->ptr;
      void *j = w->ptr;
      return (i < j) ? -1 : ((i > j) ? 1 : 0);
    }
  }
  
  SWIGRUNTIME void
  PySwigObject_dealloc(PySwigObject *self)
  {
    PyObject_DEL(self);
  }
  
  SWIGRUNTIME PyTypeObject*
  PySwigObject_type(void) {
    static char pyswigobject_type__doc__[] = 
      "Swig object carries a C/C++ instance pointer";
    
    static PyNumberMethods PySwigObject_as_number = {
      (binaryfunc)0, /*nb_add*/
      (binaryfunc)0, /*nb_subtract*/
      (binaryfunc)0, /*nb_multiply*/
      (binaryfunc)0, /*nb_divide*/
      (binaryfunc)0, /*nb_remainder*/
      (binaryfunc)0, /*nb_divmod*/
      (ternaryfunc)0,/*nb_power*/
      (unaryfunc)0,  /*nb_negative*/
      (unaryfunc)0,  /*nb_positive*/
      (unaryfunc)0,  /*nb_absolute*/
      (inquiry)0,    /*nb_nonzero*/
      0,		   /*nb_invert*/
      0,		   /*nb_lshift*/
      0,		   /*nb_rshift*/
      0,		   /*nb_and*/
      0,		   /*nb_xor*/
      0,		   /*nb_or*/
      (coercion)0,   /*nb_coerce*/
      (unaryfunc)PySwigObject_long, /*nb_int*/
      (unaryfunc)PySwigObject_long, /*nb_long*/
      (unaryfunc)0,                 /*nb_float*/
      (unaryfunc)PySwigObject_oct,  /*nb_oct*/
      (unaryfunc)PySwigObject_hex,  /*nb_hex*/
  #if PY_VERSION_HEX >= 0x02000000
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
  #endif
    };
  
    static PyTypeObject pyswigobject_type
  #if !defined(__cplusplus)
    ;  
    static int type_init = 0;
    if (!type_init) {
      PyTypeObject tmp
  #endif
      = {
      PyObject_HEAD_INIT(&PyType_Type)
      0,					/*ob_size*/
      (char *)"PySwigObject",		/*tp_name*/
      sizeof(PySwigObject),		/*tp_basicsize*/
      0,					/*tp_itemsize*/
      /* methods */
      (destructor)PySwigObject_dealloc,	/*tp_dealloc*/
      (printfunc)PySwigObject_print,	/*tp_print*/
      (getattrfunc)0,			/*tp_getattr*/
      (setattrfunc)0,			/*tp_setattr*/
      (cmpfunc)PySwigObject_compare,	/*tp_compare*/
      (reprfunc)PySwigObject_repr,	/*tp_repr*/
      &PySwigObject_as_number,	        /*tp_as_number*/
      0,					/*tp_as_sequence*/
      0,					/*tp_as_mapping*/
      (hashfunc)0,			/*tp_hash*/
      (ternaryfunc)0,			/*tp_call*/
      (reprfunc)PySwigObject_str,		/*tp_str*/
      /* Space for future expansion */
      0,0,0,0,
      pyswigobject_type__doc__, 	        /* Documentation string */
  #if PY_VERSION_HEX >= 0x02000000
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
  #endif
  #if PY_VERSION_HEX >= 0x02010000
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
  #endif
  #if PY_VERSION_HEX >= 0x02020000
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
  #endif
  #if PY_VERSION_HEX >= 0x02030000
      0,                                  /* tp_del */
  #endif
  #ifdef COUNT_ALLOCS
      0,0,0,0                             /* tp_alloc -> tp_next */
  #endif
      };
  #if !defined(__cplusplus)
      pyswigobject_type = tmp;
      type_init = 1;
    }
  #endif
    return &pyswigobject_type;
  }
  
  SWIGRUNTIME PyObject *
  PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
  {
    PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
    if (self) {
      self->ptr = ptr;
      self->desc = desc;
    }
    return (PyObject *)self;
  }
  
  SWIGRUNTIMEINLINE void *
  PySwigObject_AsVoidPtr(PyObject *self)
  {
    return ((PySwigObject *)self)->ptr;
  }
  
  SWIGRUNTIMEINLINE const char *
  PySwigObject_GetDesc(PyObject *self)
  {
    return ((PySwigObject *)self)->desc;
  }
  
  SWIGRUNTIMEINLINE int
  PySwigObject_Check(PyObject *op) {
    return ((op)->ob_type == PySwigObject_type()) 
      || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
  }
  
  /* -----------------------------------------------------------------------------
   * Implements a simple Swig Packed type, and use it instead of string
   * ----------------------------------------------------------------------------- */
  
  typedef struct {
    PyObject_HEAD
    void *pack;
    const char *desc;
    size_t size;
  } PySwigPacked;
  
  SWIGRUNTIME int
  PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
  {
    char result[SWIG_BUFFER_SIZE];
    flags = flags;
    fputs("<Swig Packed ", fp); 
    if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
      fputs("at ", fp); 
      fputs(result, fp); 
    }
    fputs(v->desc,fp); 
    fputs(">", fp);
    return 0; 
  }
    
  SWIGRUNTIME PyObject *
  PySwigPacked_repr(PySwigPacked *v)
  {
    char result[SWIG_BUFFER_SIZE];
    if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
      return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
    } else {
      return PyString_FromFormat("<Swig Packed %s>", v->desc);
    }  
  }
  
  SWIGRUNTIME PyObject *
  PySwigPacked_str(PySwigPacked *v)
  {
    char result[SWIG_BUFFER_SIZE];
    if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
      return PyString_FromFormat("%s%s", result, v->desc);
    } else {
      return PyString_FromFormat("%s", v->desc);
    }  
  }
  
  SWIGRUNTIME int
  PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
  {
    int c = strcmp(v->desc, w->desc);
    if (c) {
      return (c > 0) ? 1 : -1;
    } else {
      size_t i = v->size;
      size_t j = w->size;
      int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
      return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
    }
  }
  
  SWIGRUNTIME void
  PySwigPacked_dealloc(PySwigPacked *self)
  {
    free(self->pack);
    PyObject_DEL(self);
  }
  
  SWIGRUNTIME PyTypeObject*
  PySwigPacked_type(void) {
    static char pyswigpacked_type__doc__[] = 
      "Swig object carries a C/C++ instance pointer";
    static PyTypeObject pyswigpacked_type
  #if !defined(__cplusplus)
    ;
    static int type_init = 0;  
    if (!type_init) {
      PyTypeObject tmp
  #endif
      = {
      PyObject_HEAD_INIT(&PyType_Type)
      0,					/*ob_size*/
      (char *)"PySwigPacked",		/*tp_name*/
      sizeof(PySwigPacked),		/*tp_basicsize*/
      0,					/*tp_itemsize*/
      /* methods */
      (destructor)PySwigPacked_dealloc,	/*tp_dealloc*/
      (printfunc)PySwigPacked_print,	/*tp_print*/
      (getattrfunc)0,			/*tp_getattr*/
      (setattrfunc)0,			/*tp_setattr*/
      (cmpfunc)PySwigPacked_compare,	/*tp_compare*/
      (reprfunc)PySwigPacked_repr,	/*tp_repr*/
      0,	                                /*tp_as_number*/
      0,					/*tp_as_sequence*/
      0,					/*tp_as_mapping*/
      (hashfunc)0,			/*tp_hash*/
      (ternaryfunc)0,			/*tp_call*/
      (reprfunc)PySwigPacked_str,		/*tp_str*/
      /* Space for future expansion */
      0,0,0,0,
      pyswigpacked_type__doc__, 	        /* Documentation string */
  #if PY_VERSION_HEX >= 0x02000000
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
  #endif
  #if PY_VERSION_HEX >= 0x02010000
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
  #endif
  #if PY_VERSION_HEX >= 0x02020000         
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
  #endif
  #if PY_VERSION_HEX >= 0x02030000
      0,                                  /* tp_del */
  #endif
  #ifdef COUNT_ALLOCS
      0,0,0,0                             /* tp_alloc -> tp_next */
  #endif
      };
  #if !defined(__cplusplus)
      pyswigpacked_type = tmp;
      type_init = 1;
    }
  #endif
    return &pyswigpacked_type;
  }
  
  SWIGRUNTIME PyObject *
  PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
  {
    PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
    if (self == NULL) {
      return NULL;
    } else {
      void *pack = malloc(size);
      if (pack) {
        memcpy(pack, ptr, size);
        self->pack = pack;
        self->desc = desc;
        self->size = size;
        return (PyObject *) self;
      }
      return NULL;
    }
  }
  
  SWIGRUNTIMEINLINE const char *
  PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
  {
    PySwigPacked *self = (PySwigPacked *)obj;
    if (self->size != size) return 0;
    memcpy(ptr, self->pack, size);
    return self->desc;
  }
  
  SWIGRUNTIMEINLINE const char *
  PySwigPacked_GetDesc(PyObject *self)
  {
    return ((PySwigPacked *)self)->desc;
  }
  
  SWIGRUNTIMEINLINE int
  PySwigPacked_Check(PyObject *op) {
    return ((op)->ob_type == PySwigPacked_type()) 
      || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
  }
  
  #else
  /* -----------------------------------------------------------------------------
   * Use the old Python PyCObject instead of PySwigObject
   * ----------------------------------------------------------------------------- */
  
  #define PySwigObject_GetDesc(obj)	           PyCObject_GetDesc(obj)
  #define PySwigObject_Check(obj)	           PyCObject_Check(obj)
  #define PySwigObject_AsVoidPtr(obj)	   PyCObject_AsVoidPtr(obj)
  #define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)
  
  #endif
  
  #endif
  
  /* -----------------------------------------------------------------------------
   * errors manipulation
   * ----------------------------------------------------------------------------- */
  
  SWIGRUNTIME void
  SWIG_Python_TypeError(const char *type, PyObject *obj)
  {
    if (type) {
  #if defined(SWIG_COBJECT_TYPES)
      if (obj && PySwigObject_Check(obj)) {
        const char *otype = (const char *) PySwigObject_GetDesc(obj);
        if (otype) {
  	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
  		     type, otype);
  	return;
        }
      } else 
  #endif      
      {
        const char *otype = (obj ? obj->ob_type->tp_name : 0); 
        if (otype) {
  	PyObject *str = PyObject_Str(obj);
  	const char *cstr = str ? PyString_AsString(str) : 0;
  	if (cstr) {
  	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
  		       type, otype, cstr);
  	} else {
  	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
  		       type, otype);
  	}
  	Py_XDECREF(str);
  	return;
        }
      }   
      PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
    } else {
      PyErr_Format(PyExc_TypeError, "unexpected type is received");
    }
  }
  
  SWIGRUNTIMEINLINE void
  SWIG_Python_NullRef(const char *type)
  {
    if (type) {
      PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
    } else {
      PyErr_Format(PyExc_TypeError, "null reference was received");
    }
  }
  
  SWIGRUNTIME int
  SWIG_Python_AddErrMesg(const char* mesg, int infront)
  {
    if (PyErr_Occurred()) {
      PyObject *type = 0;
      PyObject *value = 0;
      PyObject *traceback = 0;
      PyErr_Fetch(&type, &value, &traceback);
      if (value) {
        PyObject *old_str = PyObject_Str(value);
        Py_XINCREF(type);
        PyErr_Clear();
        if (infront) {
  	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
        } else {
  	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
        }
        Py_DECREF(old_str);
      }
      return 1;
    } else {
      return 0;
    }
  }
  
  SWIGRUNTIME int
  SWIG_Python_ArgFail(int argnum)
  {
    if (PyErr_Occurred()) {
      /* add information about failing argument */
      char mesg[256];
      PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
      return SWIG_Python_AddErrMesg(mesg, 1);
    } else {
      return 0;
    }
  }
  
  
  /* -----------------------------------------------------------------------------
   * pointers/data manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Convert a pointer value */
  SWIGRUNTIME int
  SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
    swig_cast_info *tc;
    const char *c = 0;
    static PyObject *SWIG_this = 0;
    int    newref = 0;
    PyObject  *pyobj = 0;
    void *vptr;
    
    if (!obj) return 0;
    if (obj == Py_None) {
      *ptr = 0;
      return 0;
    }
  
  #ifdef SWIG_COBJECT_TYPES
    if (!(PySwigObject_Check(obj))) {
      if (!SWIG_this)
        SWIG_this = PyString_FromString("this");
      pyobj = obj;
      obj = PyObject_GetAttr(obj,SWIG_this);
      newref = 1;
      if (!obj) goto type_error;
      if (!PySwigObject_Check(obj)) {
        Py_DECREF(obj);
        goto type_error;
      }
    }  
    vptr = PySwigObject_AsVoidPtr(obj);
    c = (const char *) PySwigObject_GetDesc(obj);
    if (newref) { Py_DECREF(obj); }
    goto type_check;
  #else
    if (!(PyString_Check(obj))) {
      if (!SWIG_this)
        SWIG_this = PyString_FromString("this");
      pyobj = obj;
      obj = PyObject_GetAttr(obj,SWIG_this);
      newref = 1;
      if (!obj) goto type_error;
      if (!PyString_Check(obj)) {
        Py_DECREF(obj);
        goto type_error;
      }
    } 
    c = PyString_AS_STRING(obj);
    /* Pointer values must start with leading underscore */
    c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
    if (newref) { Py_DECREF(obj); }
    if (!c) goto type_error;
  #endif
  
  type_check:
    if (ty) {
      tc = SWIG_TypeCheck(c,ty);
      if (!tc) goto type_error;
      *ptr = SWIG_TypeCast(tc,vptr);
    } else {
      *ptr = vptr;
    }
    if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
      PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
    }
    return 0;
  
  type_error:
    PyErr_Clear();
    if (pyobj && !obj) {    
      obj = pyobj;
      if (PyCFunction_Check(obj)) {
        /* here we get the method pointer for callbacks */
        char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
        c = doc ? strstr(doc, "swig_ptr: ") : 0;
        if (c) {
  	c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
  	if (!c) goto type_error;
  	goto type_check;
        }
      }
    }
    if (flags & SWIG_POINTER_EXCEPTION) {
      if (ty) {
        SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      } else {
        SWIG_Python_TypeError("C/C++ pointer", obj);
      }
    }
    return -1;
  }
  
  /* Convert a pointer value, signal an exception on a type mismatch */
  SWIGRUNTIME void *
  SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
    void *result;
    if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
      PyErr_Clear();
      if (flags & SWIG_POINTER_EXCEPTION) {
        SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
        SWIG_Python_ArgFail(argnum);
      }
    }
    return result;
  }
  
  /* Convert a packed value value */
  SWIGRUNTIME int
  SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
    swig_cast_info *tc;
    const char *c = 0;
  
  #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
    c = PySwigPacked_UnpackData(obj, ptr, sz);
  #else
    if ((!obj) || (!PyString_Check(obj))) goto type_error;
    c = PyString_AS_STRING(obj);
    /* Pointer values must start with leading underscore */
    c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
  #endif
    if (!c) goto type_error;
    if (ty) {
      tc = SWIG_TypeCheck(c,ty);
      if (!tc) goto type_error;
    }
    return 0;
  
  type_error:
    PyErr_Clear();
    if (flags & SWIG_POINTER_EXCEPTION) {
      if (ty) {
        SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      } else {
        SWIG_Python_TypeError("C/C++ packed data", obj);
      }
    }
    return -1;
  }  
  
  /* Create a new array object */
  SWIGRUNTIME PyObject *
  SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
    PyObject *robj = 0;
    if (!type) {
      if (!PyErr_Occurred()) {
        PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
      }
      return robj;
    }
    if (!ptr) {
      Py_INCREF(Py_None);
      return Py_None;
    }
  #ifdef SWIG_COBJECT_TYPES
    robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
  #else
    {
      char result[SWIG_BUFFER_SIZE];
      robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
        PyString_FromString(result) : 0;
    }
  #endif
    if (!robj || (robj == Py_None)) return robj;
    if (type->clientdata) {
      PyObject *inst;
      PyObject *args = Py_BuildValue((char*)"(O)", robj);
      Py_DECREF(robj);
      inst = PyObject_CallObject((PyObject *) type->clientdata, args);
      Py_DECREF(args);
      if (inst) {
        if (own) {
          PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
        }
        robj = inst;
      }
    }
    return robj;
  }
  
  SWIGRUNTIME PyObject *
  SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
    PyObject *robj = 0;
    if (!ptr) {
      Py_INCREF(Py_None);
      return Py_None;
    }
  #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
    robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
  #else
    {
      char result[SWIG_BUFFER_SIZE];
      robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
        PyString_FromString(result) : 0;
    }
  #endif
    return robj;
  }
  
  /* -----------------------------------------------------------------------------*
   *  Get type list 
   * -----------------------------------------------------------------------------*/
  
  #ifdef SWIG_LINK_RUNTIME
  void *SWIG_ReturnGlobalTypeList(void *);
  #endif
  
  SWIGRUNTIME swig_module_info *
  SWIG_Python_GetModule(void) {
    static void *type_pointer = (void *)0;
    /* first check if module already created */
    if (!type_pointer) {
  #ifdef SWIG_LINK_RUNTIME
      type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  #else
      type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
  				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
      if (PyErr_Occurred()) {
        PyErr_Clear();
        type_pointer = (void *)0;
      }
    }
  #endif
    return (swig_module_info *) type_pointer;
  }
  
  SWIGRUNTIME void
  SWIG_Python_SetModule(swig_module_info *swig_module) {
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
  
    PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
  				   swig_empty_runtime_method_table);
    PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
    if (pointer && module) {
      PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    }
  }
  
  #ifdef __cplusplus
  }
  #endif
  
  
  /* -------- TYPES TABLE (BEGIN) -------- */
  
  #define SWIGTYPE_p_Vgrid swig_types[0]
  #define SWIGTYPE_p_char swig_types[1]
  #define SWIGTYPE_p_double swig_types[2]
  #define SWIGTYPE_p_p_Vgrid swig_types[3]
  #define SWIGTYPE_ptrdiff_t swig_types[4]
  #define SWIGTYPE_size_t swig_types[5]
  static swig_type_info *swig_types[6];
  static swig_module_info swig_module = {swig_types, 6, 0, 0, 0, 0};
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
  
  /* -------- TYPES TABLE (END) -------- */
  
  
  /*-----------------------------------------------
                @(target):= _vgrid.so
    ------------------------------------------------*/
  #define SWIG_init    init_vgrid
  
  #define SWIG_name    "_vgrid"
  
  #include "routines.h"
  #include "apbs/vgrid.h"
  
  
  double *null_array(){
       return NULL;
  }
  
  
  #include <limits.h>
  
  
  SWIGINTERN int
    SWIG_CheckLongInRange(long value, long min_value, long max_value,
  			const char *errmsg)
  {
    if (value < min_value) {
      if (errmsg) {
        PyErr_Format(PyExc_OverflowError, 
  		   "value %ld is less than '%s' minimum %ld", 
  		   value, errmsg, min_value);
      }
      return 0;    
    } else if (value > max_value) {
      if (errmsg) {
        PyErr_Format(PyExc_OverflowError,
  		   "value %ld is greater than '%s' maximum %ld", 
  		   value, errmsg, max_value);
      }
      return 0;
    }
    return 1;
  }
  
  
  SWIGINTERN int
    SWIG_AsVal_long(PyObject * obj, long* val)
  {
    if (PyInt_Check(obj)) {
      if (val) *val = PyInt_AS_LONG(obj);
      return 1;
    }
    if (PyLong_Check(obj)) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
        if (val) *val = v;
        return 1;
      } else {
        if (!val) PyErr_Clear();
        return 0;
      }
    }
    if (val) {
      SWIG_type_error("long", obj);
    }
    return 0;
   }
  
  
  #if INT_MAX != LONG_MAX
  SWIGINTERN int
    SWIG_AsVal_int(PyObject *obj, int *val)
  { 
    const char* errmsg = val ? "int" : (char*)0;
    long v;
    if (SWIG_AsVal_long(obj, &v)) {
      if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
        if (val) *val = (int)(v);
        return 1;
      } else {
        return 0;
      }
    } else {
      PyErr_Clear();
    }
    if (val) {
      SWIG_type_error(errmsg, obj);
    }
    return 0;    
  }
  #else
  SWIGINTERNINLINE int
    SWIG_AsVal_int(PyObject *obj, int *val)
  {
    return SWIG_AsVal_long(obj,(long*)val);
  }
  #endif
  
  
  SWIGINTERNINLINE int
  SWIG_As_int(PyObject* obj)
  {
    int v;
    if (!SWIG_AsVal_int(obj, &v)) {
      /*
        this is needed to make valgrind/purify happier. 
       */
      memset((void*)&v, 0, sizeof(int));
    }
    return v;
  }
  
    
  SWIGINTERNINLINE int
  SWIG_Check_int(PyObject* obj)
  {
    return SWIG_AsVal_int(obj, (int*)0);
  }
  
  
    /*@/usr/local/share/swig/1.3.25/python/pymacros.swg,66,SWIG_define@*/
  #define SWIG_From_int PyInt_FromLong
  /*@@*/
  
  
  SWIGINTERN int
    SWIG_AsVal_double(PyObject *obj, double *val)
  {
    if (PyFloat_Check(obj)) {
      if (val) *val = PyFloat_AS_DOUBLE(obj);
      return 1;
    }  
    if (PyInt_Check(obj)) {
      if (val) *val = PyInt_AS_LONG(obj);
      return 1;
    }
    if (PyLong_Check(obj)) {
      double v = PyLong_AsDouble(obj);
      if (!PyErr_Occurred()) {
        if (val) *val = v;
        return 1;
      } else {
        if (!val) PyErr_Clear();
        return 0;
      }
    }
    if (val) {
      SWIG_type_error("double", obj);
    }
    return 0;
  }
  
  
  SWIGINTERNINLINE double
  SWIG_As_double(PyObject* obj)
  {
    double v;
    if (!SWIG_AsVal_double(obj, &v)) {
      /*
        this is needed to make valgrind/purify happier. 
       */
      memset((void*)&v, 0, sizeof(double));
    }
    return v;
  }
  
    
  SWIGINTERNINLINE int
  SWIG_Check_double(PyObject* obj)
  {
    return SWIG_AsVal_double(obj, (double*)0);
  }
  
  
    /*@/usr/local/share/swig/1.3.25/python/pymacros.swg,66,SWIG_define@*/
  #define SWIG_From_double PyFloat_FromDouble
  /*@@*/
  
  
  void delete_vgrid(Vgrid *thee){
      if (thee != VNULL) {
          Vmem_free(thee->mem, (thee->nx*thee->ny*thee->nz), sizeof(double),
            (void **)&(thee->data));
          Vmem_free(VNULL, 1, sizeof(Vgrid), (void **)&thee);
          thee = VNULL;
      }
  }
  
  int Vgrid_ctor2(Vgrid *,int,int,int,double,double,double,double,double,double,double *);
  void Vgrid_dtor(Vgrid **);
  void Vgrid_dtor2(Vgrid *);
  void Vgrid_writeUHBD(Vgrid *,char const *,char const *,char const *,char const *,char *,double *);
  
  /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
  SWIGINTERN int
  SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
  {
    static swig_type_info* pchar_info = 0;
    char* vptr = 0;
    if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
    if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
      if (cptr) *cptr = vptr;
      if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
      return SWIG_OLDOBJ;
    } else {
      PyErr_Clear();
      if (PyString_Check(obj)) {
        if (cptr) {
  	*cptr = PyString_AS_STRING(obj);
  	if (psize) {
  	  *psize = PyString_GET_SIZE(obj) + 1;
  	}
        }
        return SWIG_PYSTR;
      }
    }
    if (cptr) {
      SWIG_type_error("char *", obj);
    }
    return 0;
  }
  
  
  SWIGINTERNINLINE int
  SWIG_AsCharPtr(PyObject *obj, char **val)
  {
    if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
      return 1;
    }
    if (val) {
      PyErr_Clear();
      SWIG_type_error("char *", obj);
    }
    return 0;
  }
  
  void Vgrid_writeDX(Vgrid *,char const *,char const *,char const *,char const *,char *,double *);
  int Vgrid_readDX(Vgrid *,char const *,char const *,char const *,char const *);
  void startVio();
  int Vgrid_value(Vgrid *,double [3],double *);
  
  SWIGINTERN PyObject*
  t_output_helper(PyObject* target, PyObject* o) {
    if (!target) {
      target = o;
    } else if (target == Py_None) {  
      Py_DECREF(target);
      target = o;
    } else {
      if (!PyList_Check(target)) {
        PyObject *o2 = target;
        target = PyList_New(1);
        PyList_SetItem(target, 0, o2);
      }
      PyList_Append(target,o);
      Py_DECREF(o);
      }
    return target;
  }
  
  
  int Vgrid_curvature(Vgrid *,double [3],int,double *);
  int Vgrid_gradient(Vgrid *,double [3],double [3]);
  Vgrid *Vgrid_ctor(int,int,int,double,double,double,double,double,double,double *);
  #ifdef __cplusplus
  extern "C" {
  #endif
  static PyObject *_wrap_null_array(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      double *result;
      
      if(!PyArg_ParseTuple(args,(char *)":null_array")) goto fail;
      result = (double *)null_array();
      
      resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_double, 0);
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_new_Vgrid(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *result;
      
      if(!PyArg_ParseTuple(args,(char *)":new_Vgrid")) goto fail;
      result = (Vgrid *)(Vgrid *) calloc(1, sizeof(Vgrid));
      
      resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Vgrid, 1);
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_delete_Vgrid(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:delete_Vgrid",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      free((char *) arg1);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_nx_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_nx_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (int)(SWIG_As_int(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->nx = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_nx_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_nx_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (int) ((arg1)->nx);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ny_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_ny_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (int)(SWIG_As_int(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->ny = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ny_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_ny_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (int) ((arg1)->ny);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_nz_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_nz_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (int)(SWIG_As_int(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->nz = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_nz_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_nz_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (int) ((arg1)->nz);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hx_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_hx_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->hx = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hx_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_hx_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->hx);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hy_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_hy_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->hy = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hy_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_hy_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->hy);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hzed_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_hzed_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->hzed = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_hzed_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_hzed_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->hzed);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_xmin_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_xmin_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->xmin = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_xmin_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_xmin_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->xmin);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ymin_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_ymin_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->ymin = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ymin_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_ymin_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->ymin);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_zmin_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double arg2 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_zmin_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (double)(SWIG_As_double(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      if (arg1) (arg1)->zmin = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_zmin_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_zmin_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double) ((arg1)->zmin);
      
      {
          resultobj = SWIG_From_double((double)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_data_set(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double *arg2 = (double *) 0 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OO:Vgrid_data_set",&obj0,&obj1)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_double, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
      if (SWIG_arg_fail(2)) SWIG_fail;
      if (arg1) (arg1)->data = arg2;
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_data_get(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double *result;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_data_get",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      result = (double *) ((arg1)->data);
      
      resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_double, 0);
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject * Vgrid_swigregister(PyObject *self, PyObject *args) {
      PyObject *obj;
      if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
      SWIG_TypeClientData(SWIGTYPE_p_Vgrid, obj);
      Py_INCREF(obj);
      return Py_BuildValue((char *)"");
  }
  static PyObject *_wrap_delete_vgrid(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:delete_vgrid",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      delete_vgrid(arg1);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ctor2(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      int arg2 ;
      int arg3 ;
      int arg4 ;
      double arg5 ;
      double arg6 ;
      double arg7 ;
      double arg8 ;
      double arg9 ;
      double arg10 ;
      double *arg11 = (double *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      PyObject * obj4 = 0 ;
      PyObject * obj5 = 0 ;
      PyObject * obj6 = 0 ;
      PyObject * obj7 = 0 ;
      PyObject * obj8 = 0 ;
      PyObject * obj9 = 0 ;
      PyObject * obj10 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Vgrid_ctor2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          arg2 = (int)(SWIG_As_int(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      {
          arg3 = (int)(SWIG_As_int(obj2)); 
          if (SWIG_arg_fail(3)) SWIG_fail;
      }
      {
          arg4 = (int)(SWIG_As_int(obj3)); 
          if (SWIG_arg_fail(4)) SWIG_fail;
      }
      {
          arg5 = (double)(SWIG_As_double(obj4)); 
          if (SWIG_arg_fail(5)) SWIG_fail;
      }
      {
          arg6 = (double)(SWIG_As_double(obj5)); 
          if (SWIG_arg_fail(6)) SWIG_fail;
      }
      {
          arg7 = (double)(SWIG_As_double(obj6)); 
          if (SWIG_arg_fail(7)) SWIG_fail;
      }
      {
          arg8 = (double)(SWIG_As_double(obj7)); 
          if (SWIG_arg_fail(8)) SWIG_fail;
      }
      {
          arg9 = (double)(SWIG_As_double(obj8)); 
          if (SWIG_arg_fail(9)) SWIG_fail;
      }
      {
          arg10 = (double)(SWIG_As_double(obj9)); 
          if (SWIG_arg_fail(10)) SWIG_fail;
      }
      SWIG_Python_ConvertPtr(obj10, (void **)&arg11, SWIGTYPE_p_double, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(11)) SWIG_fail;
      result = (int)Vgrid_ctor2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_dtor(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid **arg1 = (Vgrid **) 0 ;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_dtor",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      Vgrid_dtor(arg1);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_dtor2(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      PyObject * obj0 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"O:Vgrid_dtor2",&obj0)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      Vgrid_dtor2(arg1);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_writeUHBD(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      char *arg2 = (char *) 0 ;
      char *arg3 = (char *) 0 ;
      char *arg4 = (char *) 0 ;
      char *arg5 = (char *) 0 ;
      char *arg6 = (char *) 0 ;
      double *arg7 = (double *) 0 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      PyObject * obj4 = 0 ;
      PyObject * obj5 = 0 ;
      PyObject * obj6 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:Vgrid_writeUHBD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
          SWIG_arg_fail(2);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
          SWIG_arg_fail(3);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
          SWIG_arg_fail(4);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
          SWIG_arg_fail(5);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj5, (char**)&arg6)) {
          SWIG_arg_fail(6);SWIG_fail;
      }
      SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_double, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(7)) SWIG_fail;
      Vgrid_writeUHBD(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6,arg7);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_writeDX(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      char *arg2 = (char *) 0 ;
      char *arg3 = (char *) 0 ;
      char *arg4 = (char *) 0 ;
      char *arg5 = (char *) 0 ;
      char *arg6 = (char *) 0 ;
      double *arg7 = (double *) 0 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      PyObject * obj4 = 0 ;
      PyObject * obj5 = 0 ;
      PyObject * obj6 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:Vgrid_writeDX",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
          SWIG_arg_fail(2);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
          SWIG_arg_fail(3);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
          SWIG_arg_fail(4);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
          SWIG_arg_fail(5);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj5, (char**)&arg6)) {
          SWIG_arg_fail(6);SWIG_fail;
      }
      SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_double, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(7)) SWIG_fail;
      Vgrid_writeDX(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6,arg7);
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_readDX(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      char *arg2 = (char *) 0 ;
      char *arg3 = (char *) 0 ;
      char *arg4 = (char *) 0 ;
      char *arg5 = (char *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      PyObject * obj4 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOOO:Vgrid_readDX",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
          SWIG_arg_fail(2);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
          SWIG_arg_fail(3);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
          SWIG_arg_fail(4);SWIG_fail;
      }
      if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
          SWIG_arg_fail(5);SWIG_fail;
      }
      result = (int)Vgrid_readDX(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_startVio(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      
      if(!PyArg_ParseTuple(args,(char *)":startVio")) goto fail;
      startVio();
      
      Py_INCREF(Py_None); resultobj = Py_None;
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_value(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double *arg2 ;
      double *arg3 = (double *) 0 ;
      int result;
      double temp3 ;
      int res3 = 0 ;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOO:Vgrid_value",&obj0,&obj1,&obj2)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          /* Check if is a list */
          if (PyList_Check(obj1)) {
              int size = PyList_Size(obj1);
              int i = 0;
              arg2 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj1,i);
                  if (PyFloat_Check(o))
                  arg2[i] = PyFloat_AsDouble(PyList_GetItem(obj1,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg2);
                      return NULL;
                  }
              }
              arg2[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      {
          if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_double,0) != -1)) {
              temp3 = SWIG_As_double(obj2);
              if (SWIG_arg_fail(3)) SWIG_fail;
              arg3 = &temp3;
              res3 = SWIG_NEWOBJ;
          }
      }
      result = (int)Vgrid_value(arg1,arg2,arg3);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
      SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_curvature(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double *arg2 ;
      int arg3 ;
      double *arg4 = (double *) 0 ;
      int result;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOO:Vgrid_curvature",&obj0,&obj1,&obj2,&obj3)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          /* Check if is a list */
          if (PyList_Check(obj1)) {
              int size = PyList_Size(obj1);
              int i = 0;
              arg2 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj1,i);
                  if (PyFloat_Check(o))
                  arg2[i] = PyFloat_AsDouble(PyList_GetItem(obj1,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg2);
                      return NULL;
                  }
              }
              arg2[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      {
          arg3 = (int)(SWIG_As_int(obj2)); 
          if (SWIG_arg_fail(3)) SWIG_fail;
      }
      {
          if (PyList_Check(obj3)) {
              int size = PyList_Size(obj3);
              int i = 0;
              arg4 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj3,i);
                  if (PyFloat_Check(o))
                  arg4[i] = PyFloat_AsDouble(PyList_GetItem(obj3,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg4);
                      return NULL;
                  }
              }
              arg4[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      result = (int)Vgrid_curvature(arg1,arg2,arg3,arg4);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_gradient(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      Vgrid *arg1 = (Vgrid *) 0 ;
      double *arg2 ;
      double *arg3 ;
      int result;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOO:Vgrid_gradient",&obj0,&obj1,&obj2)) goto fail;
      SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_Vgrid, SWIG_POINTER_EXCEPTION | 0);
      if (SWIG_arg_fail(1)) SWIG_fail;
      {
          /* Check if is a list */
          if (PyList_Check(obj1)) {
              int size = PyList_Size(obj1);
              int i = 0;
              arg2 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj1,i);
                  if (PyFloat_Check(o))
                  arg2[i] = PyFloat_AsDouble(PyList_GetItem(obj1,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg2);
                      return NULL;
                  }
              }
              arg2[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      {
          /* Check if is a list */
          if (PyList_Check(obj2)) {
              int size = PyList_Size(obj2);
              int i = 0;
              arg3 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj2,i);
                  if (PyFloat_Check(o))
                  arg3[i] = PyFloat_AsDouble(PyList_GetItem(obj2,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg3);
                      return NULL;
                  }
              }
              arg3[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      result = (int)Vgrid_gradient(arg1,arg2,arg3);
      
      {
          resultobj = SWIG_From_int((int)(result)); 
      }
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyObject *_wrap_Vgrid_ctor(PyObject *self, PyObject *args) {
      PyObject *resultobj = NULL;
      int arg1 ;
      int arg2 ;
      int arg3 ;
      double arg4 ;
      double arg5 ;
      double arg6 ;
      double arg7 ;
      double arg8 ;
      double arg9 ;
      double *arg10 = (double *) 0 ;
      Vgrid *result;
      PyObject * obj0 = 0 ;
      PyObject * obj1 = 0 ;
      PyObject * obj2 = 0 ;
      PyObject * obj3 = 0 ;
      PyObject * obj4 = 0 ;
      PyObject * obj5 = 0 ;
      PyObject * obj6 = 0 ;
      PyObject * obj7 = 0 ;
      PyObject * obj8 = 0 ;
      PyObject * obj9 = 0 ;
      
      if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Vgrid_ctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
      {
          arg1 = (int)(SWIG_As_int(obj0)); 
          if (SWIG_arg_fail(1)) SWIG_fail;
      }
      {
          arg2 = (int)(SWIG_As_int(obj1)); 
          if (SWIG_arg_fail(2)) SWIG_fail;
      }
      {
          arg3 = (int)(SWIG_As_int(obj2)); 
          if (SWIG_arg_fail(3)) SWIG_fail;
      }
      {
          arg4 = (double)(SWIG_As_double(obj3)); 
          if (SWIG_arg_fail(4)) SWIG_fail;
      }
      {
          arg5 = (double)(SWIG_As_double(obj4)); 
          if (SWIG_arg_fail(5)) SWIG_fail;
      }
      {
          arg6 = (double)(SWIG_As_double(obj5)); 
          if (SWIG_arg_fail(6)) SWIG_fail;
      }
      {
          arg7 = (double)(SWIG_As_double(obj6)); 
          if (SWIG_arg_fail(7)) SWIG_fail;
      }
      {
          arg8 = (double)(SWIG_As_double(obj7)); 
          if (SWIG_arg_fail(8)) SWIG_fail;
      }
      {
          arg9 = (double)(SWIG_As_double(obj8)); 
          if (SWIG_arg_fail(9)) SWIG_fail;
      }
      {
          if (PyList_Check(obj9)) {
              int size = PyList_Size(obj9);
              int i = 0;
              arg10 = (double *) malloc((size+1)*sizeof(double));
              for (i = 0; i < size; i++) {
                  PyObject *o = PyList_GetItem(obj9,i);
                  if (PyFloat_Check(o))
                  arg10[i] = PyFloat_AsDouble(PyList_GetItem(obj9,i));
                  else {
                      PyErr_SetString(PyExc_TypeError,"list must contain floats");
                      free(arg10);
                      return NULL;
                  }
              }
              arg10[i] = 0;
          } else {
              PyErr_SetString(PyExc_TypeError,"not a list");
              return NULL;
          }
      }
      result = (Vgrid *)Vgrid_ctor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
      
      resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_Vgrid, 0);
      return resultobj;
      fail:
      return NULL;
  }
  
  
  static PyMethodDef SwigMethods[] = {
  	 { (char *)"null_array", _wrap_null_array, METH_VARARGS, NULL},
  	 { (char *)"new_Vgrid", _wrap_new_Vgrid, METH_VARARGS, NULL},
  	 { (char *)"delete_Vgrid", _wrap_delete_Vgrid, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_nx_set", _wrap_Vgrid_nx_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_nx_get", _wrap_Vgrid_nx_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ny_set", _wrap_Vgrid_ny_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ny_get", _wrap_Vgrid_ny_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_nz_set", _wrap_Vgrid_nz_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_nz_get", _wrap_Vgrid_nz_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hx_set", _wrap_Vgrid_hx_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hx_get", _wrap_Vgrid_hx_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hy_set", _wrap_Vgrid_hy_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hy_get", _wrap_Vgrid_hy_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hzed_set", _wrap_Vgrid_hzed_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_hzed_get", _wrap_Vgrid_hzed_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_xmin_set", _wrap_Vgrid_xmin_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_xmin_get", _wrap_Vgrid_xmin_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ymin_set", _wrap_Vgrid_ymin_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ymin_get", _wrap_Vgrid_ymin_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_zmin_set", _wrap_Vgrid_zmin_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_zmin_get", _wrap_Vgrid_zmin_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_data_set", _wrap_Vgrid_data_set, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_data_get", _wrap_Vgrid_data_get, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_swigregister", Vgrid_swigregister, METH_VARARGS, NULL},
  	 { (char *)"delete_vgrid", _wrap_delete_vgrid, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ctor2", _wrap_Vgrid_ctor2, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_dtor", _wrap_Vgrid_dtor, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_dtor2", _wrap_Vgrid_dtor2, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_writeUHBD", _wrap_Vgrid_writeUHBD, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_writeDX", _wrap_Vgrid_writeDX, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_readDX", _wrap_Vgrid_readDX, METH_VARARGS, NULL},
  	 { (char *)"startVio", _wrap_startVio, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_value", _wrap_Vgrid_value, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_curvature", _wrap_Vgrid_curvature, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_gradient", _wrap_Vgrid_gradient, METH_VARARGS, NULL},
  	 { (char *)"Vgrid_ctor", _wrap_Vgrid_ctor, METH_VARARGS, NULL},
  	 { NULL, NULL, 0, NULL }
  };
  
  
  /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
  
  static swig_type_info _swigt__p_Vgrid = {"_p_Vgrid", "Vgrid *", 0, 0, 0};
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
  static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, 0};
  static swig_type_info _swigt__p_p_Vgrid = {"_p_p_Vgrid", "Vgrid **", 0, 0, 0};
  static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
  static swig_type_info _swigt__size_t = {"_size_t", "size_t", 0, 0, 0};
  
  static swig_type_info *swig_type_initial[] = {
    &_swigt__p_Vgrid,
    &_swigt__p_char,
    &_swigt__p_double,
    &_swigt__p_p_Vgrid,
    &_swigt__ptrdiff_t,
    &_swigt__size_t,
  };
  
  static swig_cast_info _swigc__p_Vgrid[] = {  {&_swigt__p_Vgrid, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_p_Vgrid[] = {  {&_swigt__p_p_Vgrid, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__ptrdiff_t[] = {  {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__size_t[] = {  {&_swigt__size_t, 0, 0, 0},{0, 0, 0, 0}};
  
  static swig_cast_info *swig_cast_initial[] = {
    _swigc__p_Vgrid,
    _swigc__p_char,
    _swigc__p_double,
    _swigc__p_p_Vgrid,
    _swigc__ptrdiff_t,
    _swigc__size_t,
  };
  
  
  /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
  
  static swig_const_info swig_const_table[] = {
  {0, 0, 0, 0.0, 0, 0}};
  
  #ifdef __cplusplus
  }
  #endif
  /*************************************************************************
   * Type initialization:
   * This problem is tough by the requirement that no dynamic 
   * memory is used. Also, since swig_type_info structures store pointers to 
   * swig_cast_info structures and swig_cast_info structures store pointers back
   * to swig_type_info structures, we need some lookup code at initialization. 
   * The idea is that swig generates all the structures that are needed. 
   * The runtime then collects these partially filled structures. 
   * The SWIG_InitializeModule function takes these initial arrays out of 
   * swig_module, and does all the lookup, filling in the swig_module.types
   * array with the correct data and linking the correct swig_cast_info
   * structures together.
  
   * The generated swig_type_info structures are assigned staticly to an initial 
   * array. We just loop though that array, and handle each type individually.
   * First we lookup if this type has been already loaded, and if so, use the
   * loaded structure instead of the generated one. Then we have to fill in the
   * cast linked list. The cast data is initially stored in something like a
   * two-dimensional array. Each row corresponds to a type (there are the same
   * number of rows as there are in the swig_type_initial array). Each entry in
   * a column is one of the swig_cast_info structures for that type.
   * The cast_initial array is actually an array of arrays, because each row has
   * a variable number of columns. So to actually build the cast linked list,
   * we find the array of casts associated with the type, and loop through it 
   * adding the casts to the list. The one last trick we need to do is making
   * sure the type pointer in the swig_cast_info struct is correct.
  
   * First off, we lookup the cast->type name to see if it is already loaded. 
   * There are three cases to handle:
   *  1) If the cast->type has already been loaded AND the type we are adding
   *     casting info to has not been loaded (it is in this module), THEN we
   *     replace the cast->type pointer with the type pointer that has already
   *     been loaded.
   *  2) If BOTH types (the one we are adding casting info to, and the 
   *     cast->type) are loaded, THEN the cast info has already been loaded by
   *     the previous module so we just ignore it.
   *  3) Finally, if cast->type has not already been loaded, then we add that
   *     swig_cast_info to the linked list (because the cast->type) pointer will
   *     be correct.
  **/
  
  #ifdef __cplusplus
  extern "C" {
  #endif
      
      SWIGRUNTIME void
      SWIG_InitializeModule(void *clientdata) {
          swig_type_info *type, *ret;
          swig_cast_info *cast;
          size_t i;
          swig_module_info *module_head;
          static int init_run = 0;
          
          clientdata = clientdata;
          
          if (init_run) return;
          init_run = 1;
          
          /* Initialize the swig_module */
          swig_module.type_initial = swig_type_initial;
          swig_module.cast_initial = swig_cast_initial;
          
          /* Try and load any already created modules */
          module_head = SWIG_GetModule(clientdata);
          if (module_head) {
              swig_module.next = module_head->next;
              module_head->next = &swig_module;
          } else {
              /* This is the first module loaded */
              swig_module.next = &swig_module;
              SWIG_SetModule(clientdata, &swig_module);
          }
          
          /* Now work on filling in swig_module.types */
          for (i = 0; i < swig_module.size; ++i) {
              type = 0;
              
              /* if there is another module already loaded */
              if (swig_module.next != &swig_module) {
                  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
              }
              if (type) {
                  /* Overwrite clientdata field */
                  if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata;
              } else {
                  type = swig_module.type_initial[i];
              }
              
              /* Insert casting types */
              cast = swig_module.cast_initial[i];
              while (cast->type) {
                  /* Don't need to add information already in the list */
                  ret = 0;
                  if (swig_module.next != &swig_module) {
                      ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
                  }
                  if (ret && type == swig_module.type_initial[i]) {
                      cast->type = ret;
                      ret = 0;
                  }
                  
                  if (!ret) {
                      if (type->cast) {
                          type->cast->prev = cast;
                          cast->next = type->cast;
                      }
                      type->cast = cast;
                  }
                  
                  cast++;
              }
              
              /* Set entry in modules->types array equal to the type */
              swig_module.types[i] = type;
          }
      }
      
      /* This function will propagate the clientdata field of type to
      * any new swig_type_info structures that have been added into the list
      * of equivalent types.  It is like calling
      * SWIG_TypeClientData(type, clientdata) a second time.
      */
      SWIGRUNTIME void
      SWIG_PropagateClientData(void) {
          size_t i;
          swig_cast_info *equiv;
          static int init_run = 0;
          
          if (init_run) return;
          init_run = 1;
          
          for (i = 0; i < swig_module.size; i++) {
              if (swig_module.types[i]->clientdata) {
                  equiv = swig_module.types[i]->cast;
                  while (equiv) {
                      if (!equiv->converter) {
                          if (equiv->type && !equiv->type->clientdata)
                          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
                      }
                      equiv = equiv->next;
                  }
              }
          }
      }
      
  #ifdef __cplusplus
  }
  #endif
  
  
  
  #ifdef __cplusplus
  extern "C" {
  #endif
      
      /* Python-specific SWIG API */
  #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
  #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
  #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
      
      /* -----------------------------------------------------------------------------
       * global variable support code.
       * ----------------------------------------------------------------------------- */
      
      typedef struct swig_globalvar {
          char       *name;                  /* Name of global variable */
          PyObject *(*get_attr)(void);       /* Return the current value */
          int       (*set_attr)(PyObject *); /* Set the value */
          struct swig_globalvar *next;
      } swig_globalvar;
      
      typedef struct swig_varlinkobject {
          PyObject_HEAD
          swig_globalvar *vars;
      } swig_varlinkobject;
      
      SWIGINTERN PyObject *
      swig_varlink_repr(swig_varlinkobject *v) {
          v = v;
          return PyString_FromString("<Swig global variables>");
      }
      
      SWIGINTERN int
      swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
          swig_globalvar  *var;
          flags = flags;
          fprintf(fp,"Swig global variables { ");
          for (var = v->vars; var; var=var->next) {
              fprintf(fp,"%s", var->name);
              if (var->next) fprintf(fp,", ");
          }
          fprintf(fp," }\n");
          return 0;
      }
      
      SWIGINTERN PyObject *
      swig_varlink_getattr(swig_varlinkobject *v, char *n) {
          swig_globalvar *var = v->vars;
          while (var) {
              if (strcmp(var->name,n) == 0) {
                  return (*var->get_attr)();
              }
              var = var->next;
          }
          PyErr_SetString(PyExc_NameError,"Unknown C global variable");
          return NULL;
      }
      
      SWIGINTERN int
      swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
          swig_globalvar *var = v->vars;
          while (var) {
              if (strcmp(var->name,n) == 0) {
                  return (*var->set_attr)(p);
              }
              var = var->next;
          }
          PyErr_SetString(PyExc_NameError,"Unknown C global variable");
          return 1;
      }
      
      SWIGINTERN PyTypeObject*
      swig_varlink_type(void) {
          static char varlink__doc__[] = "Swig var link object";
          static PyTypeObject varlink_type
  #if !defined(__cplusplus)
          ;
          static int type_init = 0;  
          if (!type_init) {
              PyTypeObject tmp
  #endif
              = {
                  PyObject_HEAD_INIT(&PyType_Type)
                  0,                                  /* Number of items in variable part (ob_size) */
                  (char *)"swigvarlink",              /* Type name (tp_name) */
                  sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
                  0,                                  /* Itemsize (tp_itemsize) */
                  0,                                  /* Deallocator (tp_dealloc) */ 
                  (printfunc) swig_varlink_print,     /* Print (tp_print) */
                  (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
                  (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
                  0,                                  /* tp_compare */
                  (reprfunc) swig_varlink_repr,       /* tp_repr */
                  0,                                  /* tp_as_number */
                  0,                                  /* tp_as_sequence */
                  0,                                  /* tp_as_mapping */
                  0,                                  /* tp_hash */
                  0,                                  /* tp_call */
                  0,                                  /* tp_str */
                  0,                                  /* tp_getattro */
                  0,                                  /* tp_setattro */
                  0,                                  /* tp_as_buffer */
                  0,                                  /* tp_flags */
                  varlink__doc__,                     /* tp_doc */
  #if PY_VERSION_HEX >= 0x02000000
                  0,                                  /* tp_traverse */
                  0,                                  /* tp_clear */
  #endif
  #if PY_VERSION_HEX >= 0x02010000
                  0,                                  /* tp_richcompare */
                  0,                                  /* tp_weaklistoffset */
  #endif
  #if PY_VERSION_HEX >= 0x02020000
                  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
  #endif
  #if PY_VERSION_HEX >= 0x02030000
                  0,                                  /* tp_del */
  #endif
  #ifdef COUNT_ALLOCS
                  0,0,0,0                             /* tp_alloc -> tp_next */
  #endif
              };
  #if !defined(__cplusplus)
              varlink_type = tmp;
              type_init = 1;
          }
  #endif
          return &varlink_type;
      }
      
      /* Create a variable linking object for use later */
      SWIGINTERN PyObject *
      SWIG_Python_newvarlink(void) {
          swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
          if (result) {
              result->vars = 0;
          }
          return ((PyObject*) result);
      }
      
      SWIGINTERN void 
      SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
          swig_varlinkobject *v = (swig_varlinkobject *) p;
          swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
          if (gv) {
              size_t size = strlen(name)+1;
              gv->name = (char *)malloc(size);
              if (gv->name) {
                  strncpy(gv->name,name,size);
                  gv->get_attr = get_attr;
                  gv->set_attr = set_attr;
                  gv->next = v->vars;
              }
          }
          v->vars = gv;
      }
      
      /* -----------------------------------------------------------------------------
       * constants/methods manipulation
       * ----------------------------------------------------------------------------- */
      
      /* Install Constants */
      SWIGINTERN void
      SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
          PyObject *obj = 0;
          size_t i;
          for (i = 0; constants[i].type; ++i) {
              switch(constants[i].type) {
                  case SWIG_PY_INT:
                  obj = PyInt_FromLong(constants[i].lvalue);
                  break;
                  case SWIG_PY_FLOAT:
                  obj = PyFloat_FromDouble(constants[i].dvalue);
                  break;
                  case SWIG_PY_STRING:
                  if (constants[i].pvalue) {
                      obj = PyString_FromString((char *) constants[i].pvalue);
                  } else {
                      Py_INCREF(Py_None);
                      obj = Py_None;
                  }
                  break;
                  case SWIG_PY_POINTER:
                  obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
                  break;
                  case SWIG_PY_BINARY:
                  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
                  break;
                  default:
                  obj = 0;
                  break;
              }
              if (obj) {
                  PyDict_SetItemString(d,constants[i].name,obj);
                  Py_DECREF(obj);
              }
          }
      }
      
      /* -----------------------------------------------------------------------------*/
      /* Fix SwigMethods to carry the callback ptrs when needed */
      /* -----------------------------------------------------------------------------*/
      
      SWIGINTERN void
      SWIG_Python_FixMethods(PyMethodDef *methods,
      swig_const_info *const_table,
      swig_type_info **types,
      swig_type_info **types_initial) {
          size_t i;
          for (i = 0; methods[i].ml_name; ++i) {
              char *c = methods[i].ml_doc;
              if (c && (c = strstr(c, "swig_ptr: "))) {
                  int j;
                  swig_const_info *ci = 0;
                  char *name = c + 10;
                  for (j = 0; const_table[j].type; ++j) {
                      if (strncmp(const_table[j].name, name, 
                      strlen(const_table[j].name)) == 0) {
                          ci = &(const_table[j]);
                          break;
                      }
                  }
                  if (ci) {
                      size_t shift = (ci->ptype) - types;
                      swig_type_info *ty = types_initial[shift];
                      size_t ldoc = (c - methods[i].ml_doc);
                      size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
                      char *ndoc = (char*)malloc(ldoc + lptr + 10);
                      if (ndoc) {
                          char *buff = ndoc;
                          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
                          if (ptr) {
                              strncpy(buff, methods[i].ml_doc, ldoc);
                              buff += ldoc;
                              strncpy(buff, "swig_ptr: ", 10);
                              buff += 10;
                              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
                              methods[i].ml_doc = ndoc;
                          }
                      }
                  }
              }
          }
      }
      
      /* -----------------------------------------------------------------------------*
       *  Initialize type list
       * -----------------------------------------------------------------------------*/
      
  #if PY_MAJOR_VERSION < 2
      /* PyModule_AddObject function was introduced in Python 2.0.  The following function
      is copied out of Python/modsupport.c in python version 2.3.4 */
      SWIGINTERN int
      PyModule_AddObject(PyObject *m, char *name, PyObject *o)
      {
          PyObject *dict;
          if (!PyModule_Check(m)) {
              PyErr_SetString(PyExc_TypeError,
              "PyModule_AddObject() needs module as first arg");
              return -1;
          }
          if (!o) {
              PyErr_SetString(PyExc_TypeError,
              "PyModule_AddObject() needs non-NULL value");
              return -1;
          }
          
          dict = PyModule_GetDict(m);
          if (dict == NULL) {
              /* Internal error -- modules must have a dict! */
              PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
              PyModule_GetName(m));
              return -1;
          }
          if (PyDict_SetItemString(dict, name, o))
          return -1;
          Py_DECREF(o);
          return 0;
      }
  #endif
      
  #ifdef __cplusplus
  }
  #endif
  
  /* -----------------------------------------------------------------------------*
   *  Partial Init method
   * -----------------------------------------------------------------------------*/
  
  #ifdef __cplusplus
  extern "C"
  #endif
  SWIGEXPORT void SWIG_init(void) {
      static PyObject *SWIG_globals = 0; 
      PyObject *m, *d;
      if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
      
      /* Fix SwigMethods to carry the callback ptrs when needed */
      SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
      
      m = Py_InitModule((char *) SWIG_name, SwigMethods);
      d = PyModule_GetDict(m);
      
      SWIG_InitializeModule(0);
      SWIG_InstallConstants(d,swig_const_table);
      
  }
  
  