diff --git a/Core/FormFactors/FormFactorDecoratorFactor.h b/Core/FormFactors/FormFactorDecoratorFactor.h
index 3757775bf8849bdf050be2e203bbc9973a1ca905..13084bfff3486c70ab453c8c3d0494ece1d9059a 100644
--- a/Core/FormFactors/FormFactorDecoratorFactor.h
+++ b/Core/FormFactors/FormFactorDecoratorFactor.h
@@ -26,7 +26,7 @@
 class BA_CORE_API_ FormFactorDecoratorFactor : public IFormFactorDecorator
 {
 public:
-    FormFactorDecoratorFactor(const IFormFactor &form_factor, const complex_t &factor);
+    FormFactorDecoratorFactor(const IFormFactor &form_factor, const complex_t factor);
 
     virtual ~FormFactorDecoratorFactor() {}
 
@@ -42,7 +42,7 @@ protected:
 };
 
 inline FormFactorDecoratorFactor::FormFactorDecoratorFactor(const IFormFactor &form_factor,
-                                                            const complex_t &factor)
+                                                            const complex_t factor)
     : IFormFactorDecorator(form_factor), m_factor(factor)
 {
     setName(BornAgain::FormFactorDecoratorFactorType);
diff --git a/Core/Geometry/Transform3D.cpp b/Core/Geometry/Transform3D.cpp
index 3cb1843a2a79f74e1c573cf990c9eb3df2ce6690..a64c76985237187aec0477e74c02934603ffaad5 100644
--- a/Core/Geometry/Transform3D.cpp
+++ b/Core/Geometry/Transform3D.cpp
@@ -74,8 +74,8 @@ Geometry::Transform3D Geometry::Transform3D::createRotateZ(double phi)
     return Transform3D(matrix);
 }
 
-Geometry::Transform3D Geometry::Transform3D::createRotateEuler(double alpha,
-                           double beta, double gamma)
+Geometry::Transform3D Geometry::Transform3D::createRotateEuler(
+    double alpha, double beta, double gamma)
 {
     Transform3D zrot = createRotateZ(alpha);
     Transform3D xrot = createRotateX(beta);
@@ -83,8 +83,8 @@ Geometry::Transform3D Geometry::Transform3D::createRotateEuler(double alpha,
     return zrot2*xrot*zrot;
 }
 
-void Geometry::Transform3D::calculateEulerAngles(double *p_alpha,
-    double *p_beta, double *p_gamma) const
+void Geometry::Transform3D::calculateEulerAngles(
+    double *p_alpha, double *p_beta, double *p_gamma) const
 {
     // First check if second angle is zero or pi
     if (m_matrix(2,0)==0.0 && m_matrix(2,1)==0.0) {
@@ -219,4 +219,3 @@ bool Geometry::Transform3D::isZRotation() const
     if (m_matrix(2,1) != 0.0) return false;
     return true;
 }
-
diff --git a/Core/Geometry/Transform3D.h b/Core/Geometry/Transform3D.h
index df9d099d0dd58135b06b3ff481a49600c4d3f9cf..a2f3f9d6b8f743f3ae90b8c34bb4ba6d7a895f1f 100644
--- a/Core/Geometry/Transform3D.h
+++ b/Core/Geometry/Transform3D.h
@@ -56,19 +56,16 @@ public:
     static Transform3D createRotateZ(double phi);
 
     //! Creates rotation defined by Euler angles
-    static Transform3D createRotateEuler(double alpha,
-                                         double beta, double gamma);
+    static Transform3D createRotateEuler(double alpha, double beta, double gamma);
 
     //! Calculates the Euler angles corresponding to the rotation
-    void calculateEulerAngles(double *p_alpha, double *p_beta,
-                              double *p_gamma) const;
+    void calculateEulerAngles(double *p_alpha, double *p_beta, double *p_gamma) const;
 
     //! Returns the inverse transformation.
     Transform3D getInverse() const;
 
     //! Return transformed vector _v_.
-    BasicVector3D<double>
-        transformed(const BasicVector3D<double>& v) const;
+    BasicVector3D<double> transformed(const BasicVector3D<double>& v) const;
 
     //! Return transformed vector _v_.
     BasicVector3D<complex_t>
@@ -113,5 +110,3 @@ private:
 }// namespace Geometry
 
 #endif /* GEOMETRY_TRANSFORM3D_H */
-
-
diff --git a/Core/PythonAPI/libBornAgainCore.py b/Core/PythonAPI/libBornAgainCore.py
index fbdbcaf5ffc5b1116e9753100a4fbdd0ffe5a18b..1a8a2f61d0a8b3661ed8d204252ecb7cf378beab 100644
--- a/Core/PythonAPI/libBornAgainCore.py
+++ b/Core/PythonAPI/libBornAgainCore.py
@@ -14213,7 +14213,7 @@ class HomogeneousMaterial(IMaterial):
 
     def __init__(self, *args):
         """
-        __init__(HomogeneousMaterial self, std::string const & name, complex_t const & refractive_index) -> HomogeneousMaterial
+        __init__(HomogeneousMaterial self, std::string const & name, complex_t const refractive_index) -> HomogeneousMaterial
         __init__(HomogeneousMaterial self, std::string const & name, double refractive_index_delta, double refractive_index_beta) -> HomogeneousMaterial
 
         HomogeneousMaterial::HomogeneousMaterial(const std::string &name, double refractive_index_delta, double refractive_index_beta)
@@ -14255,9 +14255,9 @@ class HomogeneousMaterial(IMaterial):
 
     def setRefractiveIndex(self, refractive_index):
         """
-        setRefractiveIndex(HomogeneousMaterial self, complex_t const & refractive_index)
+        setRefractiveIndex(HomogeneousMaterial self, complex_t const refractive_index)
 
-        void HomogeneousMaterial::setRefractiveIndex(const complex_t &refractive_index)
+        void HomogeneousMaterial::setRefractiveIndex(const complex_t refractive_index)
 
         Set refractive index. 
 
@@ -14300,7 +14300,7 @@ class HomogeneousMagneticMaterial(HomogeneousMaterial):
 
     def __init__(self, *args):
         """
-        __init__(HomogeneousMagneticMaterial self, std::string const & name, complex_t const & refractive_index, kvector_t magnetic_field) -> HomogeneousMagneticMaterial
+        __init__(HomogeneousMagneticMaterial self, std::string const & name, complex_t const refractive_index, kvector_t magnetic_field) -> HomogeneousMagneticMaterial
         __init__(HomogeneousMagneticMaterial self, std::string const & name, double refractive_index_delta, double refractive_index_beta, kvector_t magnetic_field) -> HomogeneousMagneticMaterial
 
         HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(const std::string &name, double refractive_index_delta, double refractive_index_beta, const kvector_t magnetic_field)
diff --git a/Core/PythonAPI/libBornAgainCore_wrap.cxx b/Core/PythonAPI/libBornAgainCore_wrap.cxx
index 735f38db600ef2b454f5516aaebf792041bbde46..190a7a6b3b76fc7a782952095505f8d5abe38ef2 100644
--- a/Core/PythonAPI/libBornAgainCore_wrap.cxx
+++ b/Core/PythonAPI/libBornAgainCore_wrap.cxx
@@ -64590,9 +64590,8 @@ SWIGINTERN PyObject *IMaterial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyOb
 SWIGINTERN PyObject *_wrap_new_HomogeneousMaterial__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::string *arg1 = 0 ;
-  complex_t *arg2 = 0 ;
+  complex_t arg2 ;
   int res1 = SWIG_OLDOBJ ;
-  complex_t temp2 ;
   std::complex< double > val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
@@ -64615,9 +64614,8 @@ SWIGINTERN PyObject *_wrap_new_HomogeneousMaterial__SWIG_0(PyObject *SWIGUNUSEDP
   if (!SWIG_IsOK(ecode2)) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HomogeneousMaterial" "', argument " "2"" of type '" "complex_t""'");
   } 
-  temp2 = static_cast< complex_t >(val2);
-  arg2 = &temp2;
-  result = (HomogeneousMaterial *)new HomogeneousMaterial((std::string const &)*arg1,(complex_t const &)*arg2);
+  arg2 = static_cast< complex_t >(val2);
+  result = (HomogeneousMaterial *)new HomogeneousMaterial((std::string const &)*arg1,arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HomogeneousMaterial, SWIG_POINTER_NEW |  0 );
   if (SWIG_IsNewObj(res1)) delete arg1;
   return resultobj;
@@ -64724,7 +64722,7 @@ SWIGINTERN PyObject *_wrap_new_HomogeneousMaterial(PyObject *self, PyObject *arg
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HomogeneousMaterial'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    HomogeneousMaterial::HomogeneousMaterial(std::string const &,complex_t const &)\n"
+    "    HomogeneousMaterial::HomogeneousMaterial(std::string const &,complex_t const)\n"
     "    HomogeneousMaterial::HomogeneousMaterial(std::string const &,double,double)\n");
   return 0;
 }
@@ -64798,10 +64796,9 @@ fail:
 SWIGINTERN PyObject *_wrap_HomogeneousMaterial_setRefractiveIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   HomogeneousMaterial *arg1 = (HomogeneousMaterial *) 0 ;
-  complex_t *arg2 = 0 ;
+  complex_t arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  complex_t temp2 ;
   std::complex< double > val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
@@ -64817,9 +64814,8 @@ SWIGINTERN PyObject *_wrap_HomogeneousMaterial_setRefractiveIndex(PyObject *SWIG
   if (!SWIG_IsOK(ecode2)) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HomogeneousMaterial_setRefractiveIndex" "', argument " "2"" of type '" "complex_t""'");
   } 
-  temp2 = static_cast< complex_t >(val2);
-  arg2 = &temp2;
-  (arg1)->setRefractiveIndex((complex_t const &)*arg2);
+  arg2 = static_cast< complex_t >(val2);
+  (arg1)->setRefractiveIndex(arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -64871,10 +64867,9 @@ SWIGINTERN PyObject *HomogeneousMaterial_swigregister(PyObject *SWIGUNUSEDPARM(s
 SWIGINTERN PyObject *_wrap_new_HomogeneousMagneticMaterial__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::string *arg1 = 0 ;
-  complex_t *arg2 = 0 ;
+  complex_t arg2 ;
   kvector_t arg3 ;
   int res1 = SWIG_OLDOBJ ;
-  complex_t temp2 ;
   std::complex< double > val2 ;
   int ecode2 = 0 ;
   void *argp3 ;
@@ -64900,8 +64895,7 @@ SWIGINTERN PyObject *_wrap_new_HomogeneousMagneticMaterial__SWIG_0(PyObject *SWI
   if (!SWIG_IsOK(ecode2)) {
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HomogeneousMagneticMaterial" "', argument " "2"" of type '" "complex_t""'");
   } 
-  temp2 = static_cast< complex_t >(val2);
-  arg2 = &temp2;
+  arg2 = static_cast< complex_t >(val2);
   {
     res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Geometry__BasicVector3DT_double_t,  0  | 0);
     if (!SWIG_IsOK(res3)) {
@@ -64915,7 +64909,7 @@ SWIGINTERN PyObject *_wrap_new_HomogeneousMagneticMaterial__SWIG_0(PyObject *SWI
       if (SWIG_IsNewObj(res3)) delete temp;
     }
   }
-  result = (HomogeneousMagneticMaterial *)new HomogeneousMagneticMaterial((std::string const &)*arg1,(complex_t const &)*arg2,arg3);
+  result = (HomogeneousMagneticMaterial *)new HomogeneousMagneticMaterial((std::string const &)*arg1,arg2,arg3);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HomogeneousMagneticMaterial, SWIG_POINTER_NEW |  0 );
   if (SWIG_IsNewObj(res1)) delete arg1;
   return resultobj;
@@ -65047,7 +65041,7 @@ SWIGINTERN PyObject *_wrap_new_HomogeneousMagneticMaterial(PyObject *self, PyObj
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HomogeneousMagneticMaterial'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(std::string const &,complex_t const &,kvector_t const)\n"
+    "    HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(std::string const &,complex_t const,kvector_t const)\n"
     "    HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(std::string const &,double,double,kvector_t const)\n");
   return 0;
 }
@@ -97208,7 +97202,7 @@ static PyMethodDef SwigMethods[] = {
 		""},
 	 { (char *)"IMaterial_swigregister", IMaterial_swigregister, METH_VARARGS, NULL},
 	 { (char *)"new_HomogeneousMaterial", _wrap_new_HomogeneousMaterial, METH_VARARGS, (char *)"\n"
-		"HomogeneousMaterial(std::string const & name, complex_t const & refractive_index)\n"
+		"HomogeneousMaterial(std::string const & name, complex_t const refractive_index)\n"
 		"new_HomogeneousMaterial(std::string const & name, double refractive_index_delta, double refractive_index_beta) -> HomogeneousMaterial\n"
 		"\n"
 		"HomogeneousMaterial::HomogeneousMaterial(const std::string &name, double refractive_index_delta, double refractive_index_beta)\n"
@@ -97239,9 +97233,9 @@ static PyMethodDef SwigMethods[] = {
 		"\n"
 		""},
 	 { (char *)"HomogeneousMaterial_setRefractiveIndex", _wrap_HomogeneousMaterial_setRefractiveIndex, METH_VARARGS, (char *)"\n"
-		"HomogeneousMaterial_setRefractiveIndex(HomogeneousMaterial self, complex_t const & refractive_index)\n"
+		"HomogeneousMaterial_setRefractiveIndex(HomogeneousMaterial self, complex_t const refractive_index)\n"
 		"\n"
-		"void HomogeneousMaterial::setRefractiveIndex(const complex_t &refractive_index)\n"
+		"void HomogeneousMaterial::setRefractiveIndex(const complex_t refractive_index)\n"
 		"\n"
 		"Set refractive index. \n"
 		"\n"
@@ -97256,7 +97250,7 @@ static PyMethodDef SwigMethods[] = {
 		""},
 	 { (char *)"HomogeneousMaterial_swigregister", HomogeneousMaterial_swigregister, METH_VARARGS, NULL},
 	 { (char *)"new_HomogeneousMagneticMaterial", _wrap_new_HomogeneousMagneticMaterial, METH_VARARGS, (char *)"\n"
-		"HomogeneousMagneticMaterial(std::string const & name, complex_t const & refractive_index, kvector_t magnetic_field)\n"
+		"HomogeneousMagneticMaterial(std::string const & name, complex_t const refractive_index, kvector_t magnetic_field)\n"
 		"new_HomogeneousMagneticMaterial(std::string const & name, double refractive_index_delta, double refractive_index_beta, kvector_t magnetic_field) -> HomogeneousMagneticMaterial\n"
 		"\n"
 		"HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(const std::string &name, double refractive_index_delta, double refractive_index_beta, const kvector_t magnetic_field)\n"
diff --git a/Core/Samples/HomogeneousMagneticMaterial.cpp b/Core/Samples/HomogeneousMagneticMaterial.cpp
index 1f42d3da1d9bd6a8331635c2b88bae1a6078df4e..d3b512b3c7d48c9442a4679d889a53205a7c1922 100644
--- a/Core/Samples/HomogeneousMagneticMaterial.cpp
+++ b/Core/Samples/HomogeneousMagneticMaterial.cpp
@@ -19,7 +19,7 @@ const double HomogeneousMagneticMaterial::m_magnetic_prefactor
                  = -2.91042993836710484e-3;
 
 HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(
-        const std::string& name, const complex_t& refractive_index,
+        const std::string& name, const complex_t refractive_index,
         const kvector_t magnetic_field)
 : HomogeneousMaterial(name, refractive_index)
 , m_magnetic_field(magnetic_field)
diff --git a/Core/Samples/HomogeneousMagneticMaterial.h b/Core/Samples/HomogeneousMagneticMaterial.h
index 45b3df0ab1dc4fb5f4fa9fc1111e742c5ca69bbb..542baf455a31445927f9ef43f42b000609c884a9 100644
--- a/Core/Samples/HomogeneousMagneticMaterial.h
+++ b/Core/Samples/HomogeneousMagneticMaterial.h
@@ -35,7 +35,7 @@ public:
 #endif
     //! Constructs a material with _name_, _refractive_index_ and
     //! _magnetic_field_
-    HomogeneousMagneticMaterial(const std::string &name, const complex_t &refractive_index,
+    HomogeneousMagneticMaterial(const std::string &name, const complex_t refractive_index,
                                 const kvector_t magnetic_field);
 
     //! Constructs a material with _name_, refractive_index parameters and
diff --git a/Core/Samples/HomogeneousMaterial.h b/Core/Samples/HomogeneousMaterial.h
index 86fbc407ee735815ed7b96a4c2ef23b307129e8b..a6445d9e520cad283373adad50e955c8b19c2197 100644
--- a/Core/Samples/HomogeneousMaterial.h
+++ b/Core/Samples/HomogeneousMaterial.h
@@ -27,7 +27,7 @@ class BA_CORE_API_ HomogeneousMaterial : public IMaterial
 {
 public:
     //! Constructs a material with _name_ and _refractive_index_.
-    HomogeneousMaterial(const std::string &name, const complex_t &refractive_index)
+    HomogeneousMaterial(const std::string &name, const complex_t refractive_index)
         : IMaterial(name), m_refractive_index(refractive_index)
     {
     }
@@ -54,7 +54,7 @@ public:
     }
 
     //! Set refractive index.
-    void setRefractiveIndex(const complex_t &refractive_index)
+    void setRefractiveIndex(const complex_t refractive_index)
     {
         m_refractive_index = refractive_index;
     }
diff --git a/Fit/PythonAPI/libBornAgainFit.py b/Fit/PythonAPI/libBornAgainFit.py
index 330015dbfcaba66483ae2683fecef8fee4dbb52f..f512a6ef1cf82e9c41cb84aa5d3b12bca5577bdb 100644
--- a/Fit/PythonAPI/libBornAgainFit.py
+++ b/Fit/PythonAPI/libBornAgainFit.py
@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.8
+# Version 3.0.7
 #
 # Do not make changes to this file unless you know what you are doing--modify
 # the SWIG interface file instead.
@@ -77,7 +77,7 @@ def _swig_getattr(self, class_type, name):
 def _swig_repr(self):
     try:
         strthis = "proxy of " + self.this.__repr__()
-    except Exception:
+    except:
         strthis = ""
     return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
@@ -93,13 +93,12 @@ except AttributeError:
 try:
     import weakref
     weakref_proxy = weakref.proxy
-except Exception:
+except:
     weakref_proxy = lambda x: x
 
 
 class SwigPyIterator(_object):
-    """Proxy of C++ swig::SwigPyIterator class."""
-
+    """Proxy of C++ swig::SwigPyIterator class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
     __swig_getmethods__ = {}
@@ -208,8 +207,7 @@ SwigPyIterator_swigregister(SwigPyIterator)
 _libBornAgainFit.SHARED_PTR_DISOWN_swigconstant(_libBornAgainFit)
 SHARED_PTR_DISOWN = _libBornAgainFit.SHARED_PTR_DISOWN
 class vdouble1d_t(_object):
-    """Proxy of C++ std::vector<(double)> class."""
-
+    """Proxy of C++ std::vector<(double)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble1d_t, name, value)
     __swig_getmethods__ = {}
@@ -238,6 +236,11 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
+        return _libBornAgainFit.vdouble1d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
         return _libBornAgainFit.vdouble1d_t___getslice__(self, i, j)
@@ -245,8 +248,8 @@ class vdouble1d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
+        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         """
         return _libBornAgainFit.vdouble1d_t___setslice__(self, *args)
 
@@ -281,11 +284,6 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
-        return _libBornAgainFit.vdouble1d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
         return _libBornAgainFit.vdouble1d_t_append(self, x)
@@ -301,11 +299,21 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble1d_t self)"""
+        return _libBornAgainFit.vdouble1d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble1d_t self, vdouble1d_t v)"""
         return _libBornAgainFit.vdouble1d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
+        return _libBornAgainFit.vdouble1d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble1d_t self) -> std::vector< double >::iterator"""
         return _libBornAgainFit.vdouble1d_t_begin(self)
@@ -326,16 +334,6 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble1d_t self)"""
-        return _libBornAgainFit.vdouble1d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
-        return _libBornAgainFit.vdouble1d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble1d_t self)"""
         return _libBornAgainFit.vdouble1d_t_pop_back(self)
@@ -359,7 +357,7 @@ class vdouble1d_t(_object):
         this = _libBornAgainFit.new_vdouble1d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -413,8 +411,7 @@ vdouble1d_t_swigregister = _libBornAgainFit.vdouble1d_t_swigregister
 vdouble1d_t_swigregister(vdouble1d_t)
 
 class vdouble2d_t(_object):
-    """Proxy of C++ std::vector<(std::vector<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::vector<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble2d_t, name, value)
     __swig_getmethods__ = {}
@@ -443,6 +440,11 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble2d_t self) -> vdouble1d_t"""
+        return _libBornAgainFit.vdouble2d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
         return _libBornAgainFit.vdouble2d_t___getslice__(self, i, j)
@@ -450,8 +452,8 @@ class vdouble2d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
+        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         """
         return _libBornAgainFit.vdouble2d_t___setslice__(self, *args)
 
@@ -486,11 +488,6 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble2d_t self) -> vdouble1d_t"""
-        return _libBornAgainFit.vdouble2d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble2d_t self, vdouble1d_t x)"""
         return _libBornAgainFit.vdouble2d_t_append(self, x)
@@ -506,11 +503,21 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble2d_t self)"""
+        return _libBornAgainFit.vdouble2d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble2d_t self, vdouble2d_t v)"""
         return _libBornAgainFit.vdouble2d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
+        return _libBornAgainFit.vdouble2d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
         return _libBornAgainFit.vdouble2d_t_begin(self)
@@ -531,16 +538,6 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble2d_t self)"""
-        return _libBornAgainFit.vdouble2d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
-        return _libBornAgainFit.vdouble2d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble2d_t self)"""
         return _libBornAgainFit.vdouble2d_t_pop_back(self)
@@ -564,7 +561,7 @@ class vdouble2d_t(_object):
         this = _libBornAgainFit.new_vdouble2d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -618,8 +615,7 @@ vdouble2d_t_swigregister = _libBornAgainFit.vdouble2d_t_swigregister
 vdouble2d_t_swigregister(vdouble2d_t)
 
 class vector_integer_t(_object):
-    """Proxy of C++ std::vector<(int)> class."""
-
+    """Proxy of C++ std::vector<(int)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_integer_t, name, value)
     __swig_getmethods__ = {}
@@ -648,6 +644,11 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
+        return _libBornAgainFit.vector_integer_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
         return _libBornAgainFit.vector_integer_t___getslice__(self, i, j)
@@ -655,8 +656,8 @@ class vector_integer_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
+        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         """
         return _libBornAgainFit.vector_integer_t___setslice__(self, *args)
 
@@ -691,11 +692,6 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
-        return _libBornAgainFit.vector_integer_t_pop(self)
-
-
     def append(self, x):
         """append(vector_integer_t self, std::vector< int >::value_type const & x)"""
         return _libBornAgainFit.vector_integer_t_append(self, x)
@@ -711,11 +707,21 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_integer_t self)"""
+        return _libBornAgainFit.vector_integer_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_integer_t self, vector_integer_t v)"""
         return _libBornAgainFit.vector_integer_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
+        return _libBornAgainFit.vector_integer_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_integer_t self) -> std::vector< int >::iterator"""
         return _libBornAgainFit.vector_integer_t_begin(self)
@@ -736,16 +742,6 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_integer_t self)"""
-        return _libBornAgainFit.vector_integer_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
-        return _libBornAgainFit.vector_integer_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_integer_t self)"""
         return _libBornAgainFit.vector_integer_t_pop_back(self)
@@ -769,7 +765,7 @@ class vector_integer_t(_object):
         this = _libBornAgainFit.new_vector_integer_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -823,8 +819,7 @@ vector_integer_t_swigregister = _libBornAgainFit.vector_integer_t_swigregister
 vector_integer_t_swigregister(vector_integer_t)
 
 class vector_longinteger_t(_object):
-    """Proxy of C++ std::vector<(unsigned long)> class."""
-
+    """Proxy of C++ std::vector<(unsigned long)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_longinteger_t, name, value)
     __swig_getmethods__ = {}
@@ -853,6 +848,11 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
+        return _libBornAgainFit.vector_longinteger_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
         return _libBornAgainFit.vector_longinteger_t___getslice__(self, i, j)
@@ -860,8 +860,8 @@ class vector_longinteger_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
+        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         """
         return _libBornAgainFit.vector_longinteger_t___setslice__(self, *args)
 
@@ -896,11 +896,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
-        return _libBornAgainFit.vector_longinteger_t_pop(self)
-
-
     def append(self, x):
         """append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
         return _libBornAgainFit.vector_longinteger_t_append(self, x)
@@ -916,11 +911,21 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_longinteger_t self)"""
+        return _libBornAgainFit.vector_longinteger_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_longinteger_t self, vector_longinteger_t v)"""
         return _libBornAgainFit.vector_longinteger_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
+        return _libBornAgainFit.vector_longinteger_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
         return _libBornAgainFit.vector_longinteger_t_begin(self)
@@ -941,16 +946,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_longinteger_t self)"""
-        return _libBornAgainFit.vector_longinteger_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
-        return _libBornAgainFit.vector_longinteger_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_longinteger_t self)"""
         return _libBornAgainFit.vector_longinteger_t_pop_back(self)
@@ -974,7 +969,7 @@ class vector_longinteger_t(_object):
         this = _libBornAgainFit.new_vector_longinteger_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1028,8 +1023,7 @@ vector_longinteger_t_swigregister = _libBornAgainFit.vector_longinteger_t_swigre
 vector_longinteger_t_swigregister(vector_longinteger_t)
 
 class vector_complex_t(_object):
-    """Proxy of C++ std::vector<(std::complex<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::complex<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_complex_t, name, value)
     __swig_getmethods__ = {}
@@ -1058,6 +1052,11 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
+        return _libBornAgainFit.vector_complex_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
         return _libBornAgainFit.vector_complex_t___getslice__(self, i, j)
@@ -1065,8 +1064,8 @@ class vector_complex_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
+        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         """
         return _libBornAgainFit.vector_complex_t___setslice__(self, *args)
 
@@ -1101,11 +1100,6 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
-        return _libBornAgainFit.vector_complex_t_pop(self)
-
-
     def append(self, x):
         """append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
         return _libBornAgainFit.vector_complex_t_append(self, x)
@@ -1121,11 +1115,21 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_complex_t self)"""
+        return _libBornAgainFit.vector_complex_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_complex_t self, vector_complex_t v)"""
         return _libBornAgainFit.vector_complex_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
+        return _libBornAgainFit.vector_complex_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
         return _libBornAgainFit.vector_complex_t_begin(self)
@@ -1146,16 +1150,6 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_complex_t self)"""
-        return _libBornAgainFit.vector_complex_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
-        return _libBornAgainFit.vector_complex_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_complex_t self)"""
         return _libBornAgainFit.vector_complex_t_pop_back(self)
@@ -1179,7 +1173,7 @@ class vector_complex_t(_object):
         this = _libBornAgainFit.new_vector_complex_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1233,8 +1227,7 @@ vector_complex_t_swigregister = _libBornAgainFit.vector_complex_t_swigregister
 vector_complex_t_swigregister(vector_complex_t)
 
 class vector_string_t(_object):
-    """Proxy of C++ std::vector<(std::string)> class."""
-
+    """Proxy of C++ std::vector<(std::string)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_string_t, name, value)
     __swig_getmethods__ = {}
@@ -1263,6 +1256,11 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
+        return _libBornAgainFit.vector_string_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
         return _libBornAgainFit.vector_string_t___getslice__(self, i, j)
@@ -1270,8 +1268,8 @@ class vector_string_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
+        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         """
         return _libBornAgainFit.vector_string_t___setslice__(self, *args)
 
@@ -1306,11 +1304,6 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
-        return _libBornAgainFit.vector_string_t_pop(self)
-
-
     def append(self, x):
         """append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
         return _libBornAgainFit.vector_string_t_append(self, x)
@@ -1326,11 +1319,21 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_string_t self)"""
+        return _libBornAgainFit.vector_string_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_string_t self, vector_string_t v)"""
         return _libBornAgainFit.vector_string_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
+        return _libBornAgainFit.vector_string_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_string_t self) -> std::vector< std::string >::iterator"""
         return _libBornAgainFit.vector_string_t_begin(self)
@@ -1351,16 +1354,6 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_string_t self)"""
-        return _libBornAgainFit.vector_string_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
-        return _libBornAgainFit.vector_string_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_string_t self)"""
         return _libBornAgainFit.vector_string_t_pop_back(self)
@@ -1384,7 +1377,7 @@ class vector_string_t(_object):
         this = _libBornAgainFit.new_vector_string_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1450,7 +1443,6 @@ class IMinimizer(_object):
     C++ includes: IMinimizer.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IMinimizer, name, value)
     __swig_getmethods__ = {}
@@ -1704,8 +1696,7 @@ IMinimizer_swigregister = _libBornAgainFit.IMinimizer_swigregister
 IMinimizer_swigregister(IMinimizer)
 
 class IChiSquaredModule(libBornAgainCore.ICloneable):
-    """Proxy of C++ IChiSquaredModule class."""
-
+    """Proxy of C++ IChiSquaredModule class"""
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.ICloneable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1778,7 +1769,6 @@ class IFitObserver(libBornAgainCore.IObserver):
     C++ includes: IFitObserver.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IObserver]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1803,7 +1793,7 @@ class IFitObserver(libBornAgainCore.IObserver):
         this = _libBornAgainFit.new_IFitObserver(_self, update_every_nth)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def notify(self, subject):
@@ -1849,7 +1839,6 @@ class IFitStrategy(libBornAgainCore.INamed):
     C++ includes: IFitStrategy.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.INamed]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1906,7 +1895,6 @@ class FitStrategyDefault(IFitStrategy):
     C++ includes: IFitStrategy.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFitStrategy]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1927,7 +1915,7 @@ class FitStrategyDefault(IFitStrategy):
         this = _libBornAgainFit.new_FitStrategyDefault()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -1955,8 +1943,7 @@ FitStrategyDefault_swigregister = _libBornAgainFit.FitStrategyDefault_swigregist
 FitStrategyDefault_swigregister(FitStrategyDefault)
 
 class IIntensityFunction(_object):
-    """Proxy of C++ IIntensityFunction class."""
-
+    """Proxy of C++ IIntensityFunction class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IIntensityFunction, name, value)
     __swig_getmethods__ = {}
@@ -1981,8 +1968,7 @@ IIntensityFunction_swigregister = _libBornAgainFit.IIntensityFunction_swigregist
 IIntensityFunction_swigregister(IIntensityFunction)
 
 class IntensityFunctionLog(IIntensityFunction):
-    """Proxy of C++ IntensityFunctionLog class."""
-
+    """Proxy of C++ IntensityFunctionLog class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2010,14 +1996,13 @@ class IntensityFunctionLog(IIntensityFunction):
         this = _libBornAgainFit.new_IntensityFunctionLog()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 IntensityFunctionLog_swigregister = _libBornAgainFit.IntensityFunctionLog_swigregister
 IntensityFunctionLog_swigregister(IntensityFunctionLog)
 
 class IntensityFunctionSqrt(IIntensityFunction):
-    """Proxy of C++ IntensityFunctionSqrt class."""
-
+    """Proxy of C++ IntensityFunctionSqrt class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2045,14 +2030,13 @@ class IntensityFunctionSqrt(IIntensityFunction):
         this = _libBornAgainFit.new_IntensityFunctionSqrt()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 IntensityFunctionSqrt_swigregister = _libBornAgainFit.IntensityFunctionSqrt_swigregister
 IntensityFunctionSqrt_swigregister(IntensityFunctionSqrt)
 
 class IIntensityNormalizer(libBornAgainCore.IParameterized):
-    """Proxy of C++ IIntensityNormalizer class."""
-
+    """Proxy of C++ IIntensityNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2091,8 +2075,7 @@ IIntensityNormalizer_swigregister = _libBornAgainFit.IIntensityNormalizer_swigre
 IIntensityNormalizer_swigregister(IIntensityNormalizer)
 
 class IntensityNormalizer(IIntensityNormalizer):
-    """Proxy of C++ IntensityNormalizer class."""
-
+    """Proxy of C++ IntensityNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityNormalizer]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2112,7 +2095,7 @@ class IntensityNormalizer(IIntensityNormalizer):
         this = _libBornAgainFit.new_IntensityNormalizer(scale, shift)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_IntensityNormalizer
     __del__ = lambda self: None
@@ -2140,8 +2123,7 @@ IntensityNormalizer_swigregister = _libBornAgainFit.IntensityNormalizer_swigregi
 IntensityNormalizer_swigregister(IntensityNormalizer)
 
 class IntensityScaleAndShiftNormalizer(IntensityNormalizer):
-    """Proxy of C++ IntensityScaleAndShiftNormalizer class."""
-
+    """Proxy of C++ IntensityScaleAndShiftNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [IntensityNormalizer]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2161,7 +2143,7 @@ class IntensityScaleAndShiftNormalizer(IntensityNormalizer):
         this = _libBornAgainFit.new_IntensityScaleAndShiftNormalizer(scale, shift)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_IntensityScaleAndShiftNormalizer
     __del__ = lambda self: None
@@ -2179,8 +2161,7 @@ IntensityScaleAndShiftNormalizer_swigregister = _libBornAgainFit.IntensityScaleA
 IntensityScaleAndShiftNormalizer_swigregister(IntensityScaleAndShiftNormalizer)
 
 class ISquaredFunction(_object):
-    """Proxy of C++ ISquaredFunction class."""
-
+    """Proxy of C++ ISquaredFunction class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ISquaredFunction, name, value)
     __swig_getmethods__ = {}
@@ -2213,8 +2194,7 @@ ISquaredFunction_swigregister = _libBornAgainFit.ISquaredFunction_swigregister
 ISquaredFunction_swigregister(ISquaredFunction)
 
 class SquaredFunctionDefault(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionDefault class."""
-
+    """Proxy of C++ SquaredFunctionDefault class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2230,7 +2210,7 @@ class SquaredFunctionDefault(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionDefault()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionDefault
     __del__ = lambda self: None
@@ -2256,8 +2236,7 @@ SquaredFunctionDefault_swigregister = _libBornAgainFit.SquaredFunctionDefault_sw
 SquaredFunctionDefault_swigregister(SquaredFunctionDefault)
 
 class SquaredFunctionSimError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionSimError class."""
-
+    """Proxy of C++ SquaredFunctionSimError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2291,8 +2270,7 @@ SquaredFunctionSimError_swigregister = _libBornAgainFit.SquaredFunctionSimError_
 SquaredFunctionSimError_swigregister(SquaredFunctionSimError)
 
 class SquaredFunctionMeanSquaredError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionMeanSquaredError class."""
-
+    """Proxy of C++ SquaredFunctionMeanSquaredError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2326,8 +2304,7 @@ SquaredFunctionMeanSquaredError_swigregister = _libBornAgainFit.SquaredFunctionM
 SquaredFunctionMeanSquaredError_swigregister(SquaredFunctionMeanSquaredError)
 
 class SquaredFunctionSystematicError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionSystematicError class."""
-
+    """Proxy of C++ SquaredFunctionSystematicError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2361,8 +2338,7 @@ SquaredFunctionSystematicError_swigregister = _libBornAgainFit.SquaredFunctionSy
 SquaredFunctionSystematicError_swigregister(SquaredFunctionSystematicError)
 
 class SquaredFunctionGaussianError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionGaussianError class."""
-
+    """Proxy of C++ SquaredFunctionGaussianError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2396,8 +2372,7 @@ SquaredFunctionGaussianError_swigregister = _libBornAgainFit.SquaredFunctionGaus
 SquaredFunctionGaussianError_swigregister(SquaredFunctionGaussianError)
 
 class ChiSquaredModule(IChiSquaredModule):
-    """Proxy of C++ ChiSquaredModule class."""
-
+    """Proxy of C++ ChiSquaredModule class"""
     __swig_setmethods__ = {}
     for _s in [IChiSquaredModule]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2416,7 +2391,7 @@ class ChiSquaredModule(IChiSquaredModule):
         this = _libBornAgainFit.new_ChiSquaredModule(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_ChiSquaredModule
     __del__ = lambda self: None
@@ -2442,7 +2417,6 @@ class FitObject(libBornAgainCore.IParameterized):
     C++ includes: FitObject.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2482,7 +2456,7 @@ class FitObject(libBornAgainCore.IParameterized):
         this = _libBornAgainFit.new_FitObject(simulation, real_data, weight, adjust_detector_to_data)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitObject
     __del__ = lambda self: None
@@ -2583,7 +2557,6 @@ class FitOptions(_object):
     C++ includes: FitOptions.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, FitOptions, name, value)
     __swig_getmethods__ = {}
@@ -2600,7 +2573,7 @@ class FitOptions(_object):
         this = _libBornAgainFit.new_FitOptions()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitOptions
     __del__ = lambda self: None
@@ -2656,7 +2629,6 @@ class FitParameter(libBornAgainCore.INamed, libBornAgainCore.AttLimits):
     C++ includes: FitParameter.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.INamed, libBornAgainCore.AttLimits]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2681,7 +2653,7 @@ class FitParameter(libBornAgainCore.INamed, libBornAgainCore.AttLimits):
         this = _libBornAgainFit.new_FitParameter(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitParameter
     __del__ = lambda self: None
@@ -2769,7 +2741,6 @@ class FitSuite(libBornAgainCore.IObservable):
     C++ includes: FitSuite.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IObservable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2790,7 +2761,7 @@ class FitSuite(libBornAgainCore.IObservable):
         this = _libBornAgainFit.new_FitSuite()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def addSimulationAndRealData(self, *args):
@@ -3193,7 +3164,6 @@ class FitSuiteObjects(libBornAgainCore.IParameterized):
     C++ includes: FitSuiteObjects.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -3214,7 +3184,7 @@ class FitSuiteObjects(libBornAgainCore.IParameterized):
         this = _libBornAgainFit.new_FitSuiteObjects()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitSuiteObjects
     __del__ = lambda self: None
@@ -3398,7 +3368,6 @@ class FitSuiteParameters(_object):
     C++ includes: FitSuiteParameters.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, FitSuiteParameters, name, value)
     __swig_getmethods__ = {}
@@ -3415,7 +3384,7 @@ class FitSuiteParameters(_object):
         this = _libBornAgainFit.new_FitSuiteParameters()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitSuiteParameters
     __del__ = lambda self: None
@@ -3746,7 +3715,6 @@ class MinimizerOptions(_object):
     C++ includes: MinimizerOptions.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, MinimizerOptions, name, value)
     __swig_getmethods__ = {}
@@ -3763,7 +3731,7 @@ class MinimizerOptions(_object):
         this = _libBornAgainFit.new_MinimizerOptions()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_MinimizerOptions
     __del__ = lambda self: None
@@ -3975,7 +3943,6 @@ class MinimizerFactory(_object):
     C++ includes: MinimizerFactory.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, MinimizerFactory, name, value)
     __swig_getmethods__ = {}
@@ -4017,7 +3984,7 @@ class MinimizerFactory(_object):
         this = _libBornAgainFit.new_MinimizerFactory()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_MinimizerFactory
     __del__ = lambda self: None
@@ -4046,7 +4013,6 @@ class FitStrategyAdjustMinimizer(IFitStrategy):
     C++ includes: FitStrategyAdjustMinimizer.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFitStrategy]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4070,7 +4036,7 @@ class FitStrategyAdjustMinimizer(IFitStrategy):
         this = _libBornAgainFit.new_FitStrategyAdjustMinimizer(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitStrategyAdjustMinimizer
     __del__ = lambda self: None
diff --git a/Fit/PythonAPI/libBornAgainFit_wrap.cxx b/Fit/PythonAPI/libBornAgainFit_wrap.cxx
index 9cb4f35614b83b48952d05567b0ab99344010fd8..e9ad2415dfce29b4183935f10f82f07bda034728 100644
--- a/Fit/PythonAPI/libBornAgainFit_wrap.cxx
+++ b/Fit/PythonAPI/libBornAgainFit_wrap.cxx
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * 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
@@ -8,11 +8,7 @@
  * interface file instead.
  * ----------------------------------------------------------------------------- */
 
-
-#ifndef SWIGPYTHON
 #define SWIGPYTHON
-#endif
-
 #define SWIG_DIRECTORS
 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
 
@@ -1330,7 +1326,7 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
 
 /* Unpack the argument tuple */
 
-SWIGINTERN Py_ssize_t
+SWIGINTERN int
 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
 {
   if (!args) {
@@ -1344,7 +1340,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
   }  
   if (!PyTuple_Check(args)) {
     if (min <= 1 && max >= 1) {
-      Py_ssize_t i;
+      int i;
       objs[0] = args;
       for (i = 1; i < max; ++i) {
 	objs[i] = 0;
@@ -1364,7 +1360,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
 		   name, (min == max ? "" : "at most "), (int)max, (int)l);
       return 0;
     } else {
-      Py_ssize_t i;
+      int i;
       for (i = 0; i < l; ++i) {
 	objs[i] = PyTuple_GET_ITEM(args, i);
       }
@@ -1705,32 +1701,16 @@ SwigPyObject_dealloc(PyObject *v)
     if (destroy) {
       /* destroy is always a VARARGS method */
       PyObject *res;
-
-      /* PyObject_CallFunction() has the potential to silently drop
-         the active active exception.  In cases of unnamed temporary
-         variable or where we just finished iterating over a generator
-         StopIteration will be active right now, and this needs to
-         remain true upon return from SwigPyObject_dealloc.  So save
-         and restore. */
-      
-      PyObject *val = NULL, *type = NULL, *tb = NULL;
-      PyErr_Fetch(&val, &type, &tb);
-
       if (data->delargs) {
-        /* we need to create a temporary object to carry the destroy operation */
-        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
-        res = SWIG_Python_CallFunctor(destroy, tmp);
-        Py_DECREF(tmp);
+	/* we need to create a temporary object to carry the destroy operation */
+	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
+	res = SWIG_Python_CallFunctor(destroy, tmp);
+	Py_DECREF(tmp);
       } else {
-        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
-        PyObject *mself = PyCFunction_GET_SELF(destroy);
-        res = ((*meth)(mself, v));
+	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+	PyObject *mself = PyCFunction_GET_SELF(destroy);
+	res = ((*meth)(mself, v));
       }
-      if (!res)
-        PyErr_WriteUnraisable(destroy);
-
-      PyErr_Restore(val, type, tb);
-
       Py_XDECREF(res);
     } 
 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
@@ -1754,7 +1734,6 @@ SwigPyObject_append(PyObject* v, PyObject* next)
   next = tmp;
 #endif
   if (!SwigPyObject_Check(next)) {
-    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
     return NULL;
   }
   sobj->next = next;
@@ -1910,9 +1889,7 @@ SwigPyObject_TypeOnce(void) {
     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
 #endif
-#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
-#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
@@ -1992,19 +1969,10 @@ SwigPyObject_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpyobject_type = tmp;
@@ -2180,19 +2148,10 @@ SwigPyPacked_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpypacked_type = tmp;
@@ -2720,11 +2679,13 @@ 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");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs module as first arg");
     return SWIG_ERROR;
   }
   if (!o) {
-    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs non-NULL value");
     return SWIG_ERROR;
   }
   
@@ -3568,7 +3529,7 @@ static swig_module_info swig_module = {swig_types, 89, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_libBornAgainFit"
 
-#define SWIGVERSION 0x030008 
+#define SWIGVERSION 0x030007 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -3814,11 +3775,9 @@ SWIG_AsVal_double (PyObject *obj, double *val)
   if (PyFloat_Check(obj)) {
     if (val) *val = PyFloat_AsDouble(obj);
     return SWIG_OK;
-#if PY_VERSION_HEX < 0x03000000
   } else if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-#endif
   } else if (PyLong_Check(obj)) {
     double v = PyLong_AsDouble(obj);
     if (!PyErr_Occurred()) {
@@ -3910,7 +3869,18 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
+#if PY_VERSION_HEX >= 0x03000000
+      {
+        long v = PyLong_AsLong(obj);
+        if (!PyErr_Occurred()) {
+          if (v < 0) {
+            return SWIG_OverflowError;
+          }
+        } else {
+          PyErr_Clear();
+        }
+      }
+#endif
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -3967,20 +3937,16 @@ SWIGINTERNINLINE PyObject*
 SWIGINTERN int
 SWIG_AsVal_long (PyObject *obj, long* val)
 {
-#if PY_VERSION_HEX < 0x03000000
   if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-  } else
-#endif
-  if (PyLong_Check(obj)) {
+  } else if (PyLong_Check(obj)) {
     long v = PyLong_AsLong(obj);
     if (!PyErr_Occurred()) {
       if (val) *val = v;
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -4030,7 +3996,7 @@ SWIGINTERNINLINE PyObject*
 }
 
 
-namespace swig {
+namespace swig {  
   template <class Type>
   struct noconst_traits {
     typedef Type noconst_type;
@@ -4044,7 +4010,7 @@ namespace swig {
   /*
     type categories
   */
-  struct pointer_category { };
+  struct pointer_category { };  
   struct value_category { };
 
   /*
@@ -4057,12 +4023,12 @@ namespace swig {
     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
   }
 
-  template <class Type>
+  template <class Type> 
   struct traits_info {
     static swig_type_info *type_query(std::string name) {
       name += " *";
       return SWIG_TypeQuery(name.c_str());
-    }
+    }    
     static swig_type_info *type_info() {
       static swig_type_info *info = type_query(type_name<Type>());
       return info;
@@ -4083,17 +4049,17 @@ namespace swig {
       std::string ptrname = name;
       ptrname += " *";
       return ptrname;
-    }
+    }    
     static const char* type_name() {
       static std::string name = make_ptr_name(swig::type_name<Type>());
       return name.c_str();
     }
   };
 
-  template <class Type, class Category>
+  template <class Type, class Category> 
   struct traits_as { };
-
-  template <class Type, class Category>
+ 
+  template <class Type, class Category> 
   struct traits_check { };
 
 }
@@ -4437,12 +4403,6 @@ namespace swig {
     return pos;
   }
 
-  template <class Sequence>
-  inline void
-  erase(Sequence* seq, const typename Sequence::iterator& position) {
-    seq->erase(position);
-  }
-
   template <class Sequence, class Difference>
   inline Sequence*
   getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
@@ -4817,7 +4777,7 @@ namespace swig
   template <class T>
   struct SwigPySequence_Ref
   {
-    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_Ref(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -4829,7 +4789,7 @@ namespace swig
 	return swig::as<T>(item, true);
       } catch (std::exception& e) {
 	char msg[1024];
-	sprintf(msg, "in sequence element %d ", (int)_index);
+	sprintf(msg, "in sequence element %d ", _index);
 	if (!PyErr_Occurred()) {
 	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
 	}
@@ -4847,7 +4807,7 @@ namespace swig
 
   private:
     PyObject* _seq;
-    Py_ssize_t _index;
+    int _index;
   };
 
   template <class T>
@@ -4868,13 +4828,13 @@ namespace swig
     typedef Reference reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
+    typedef int difference_type;
 
     SwigPySequence_InputIterator()
     {
     }
 
-    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_InputIterator(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -4954,7 +4914,6 @@ namespace swig
     difference_type _index;
   };
 
-  // STL container wrapper around a Python sequence
   template <class T>
   struct SwigPySequence_Cont
   {
@@ -4962,8 +4921,8 @@ namespace swig
     typedef const SwigPySequence_Ref<T> const_reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
-    typedef size_t size_type;
+    typedef int difference_type;
+    typedef int size_type;
     typedef const pointer const_pointer;
     typedef SwigPySequence_InputIterator<T, reference> iterator;
     typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
@@ -5024,13 +4983,13 @@ namespace swig
 
     bool check(bool set_err = true) const
     {
-      Py_ssize_t s = size();
-      for (Py_ssize_t i = 0; i < s; ++i) {
+      int s = size();
+      for (int i = 0; i < s; ++i) {
 	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
 	if (!swig::check<value_type>(item)) {
 	  if (set_err) {
 	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", (int)i);
+	    sprintf(msg, "in sequence element %d", i);
 	    SWIG_Error(SWIG_RuntimeError, msg);
 	  }
 	  return false;
@@ -5050,17 +5009,17 @@ namespace swig
 
 
 namespace swig {
-  template <> struct traits< double > {
+  template <> struct traits<double > {
     typedef value_category category;
     static const char* type_name() { return"double"; }
-  };
-  template <>  struct traits_asval< double > {
+  };  
+  template <>  struct traits_asval<double > {   
     typedef double value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_double (obj, val);
     }
   };
-  template <>  struct traits_from< double > {
+  template <>  struct traits_from<double > {
     typedef double value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_double  (val);
@@ -5134,9 +5093,10 @@ namespace swig {
 #endif
       size_type size = seq.size();
       if (size <= (size_type)INT_MAX) {
-	PyObject *obj = PyTuple_New((Py_ssize_t)size);
-	Py_ssize_t i = 0;
-	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
+	PyObject *obj = PyTuple_New((int)size);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
 	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
 	}
 	return obj;
@@ -5167,7 +5127,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< double, std::allocator< double > > > {
+	template <>  struct traits<std::vector<double, std::allocator< double > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "double" "," "std::allocator< double >" " >";
@@ -5202,20 +5162,24 @@ SWIG_From_size_t  (size_t value)
   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 }
 
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<double,std::allocator< double > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
-    }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v=std::vector< double,std::allocator< double > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5224,8 +5188,8 @@ SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
@@ -5235,8 +5199,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5246,8 +5210,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5257,8 +5221,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
@@ -5267,13 +5231,6 @@ SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____g
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< double,std::allocator< double > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
       self->push_back(x);
     }
@@ -5283,7 +5240,7 @@ SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG
 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
 
       namespace swig {
-	template <>  struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+	template <>  struct traits<std::vector<std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
@@ -5303,20 +5260,24 @@ SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector<
 SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v=std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5325,8 +5286,8 @@ SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allo
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
@@ -5336,8 +5297,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5347,8 +5308,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5358,8 +5319,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
@@ -5368,13 +5329,6 @@ SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -5410,17 +5364,17 @@ SWIG_AsVal_int (PyObject * obj, int *val)
 
 
 namespace swig {
-  template <> struct traits< int > {
+  template <> struct traits<int > {
     typedef value_category category;
     static const char* type_name() { return"int"; }
-  };
-  template <>  struct traits_asval< int > {
+  };  
+  template <>  struct traits_asval<int > {   
     typedef int value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_int (obj, val);
     }
   };
-  template <>  struct traits_from< int > {
+  template <>  struct traits_from<int > {
     typedef int value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_int  (val);
@@ -5430,7 +5384,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< int, std::allocator< int > > > {
+	template <>  struct traits<std::vector<int, std::allocator< int > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "int" "," "std::allocator< int >" " >";
@@ -5450,20 +5404,24 @@ SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<int,std::allocator< int > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
-    }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v=std::vector< int,std::allocator< int > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5472,8 +5430,8 @@ SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____get
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
@@ -5483,8 +5441,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5494,8 +5452,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5505,8 +5463,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
@@ -5515,13 +5473,6 @@ SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< int,std::allocator< int > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
       self->push_back(x);
     }
@@ -5531,17 +5482,17 @@ SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std
 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
 
 namespace swig {
-  template <> struct traits< unsigned long > {
+  template <> struct traits<unsigned long > {
     typedef value_category category;
     static const char* type_name() { return"unsigned long"; }
-  };
-  template <>  struct traits_asval< unsigned long > {
+  };  
+  template <>  struct traits_asval<unsigned long > {   
     typedef unsigned long value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_unsigned_SS_long (obj, val);
     }
   };
-  template <>  struct traits_from< unsigned long > {
+  template <>  struct traits_from<unsigned long > {
     typedef unsigned long value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_unsigned_SS_long  (val);
@@ -5551,7 +5502,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< unsigned long, std::allocator< unsigned long > > > {
+	template <>  struct traits<std::vector<unsigned long, std::allocator< unsigned long > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "unsigned long" "," "std::allocator< unsigned long >" " >";
@@ -5571,20 +5522,24 @@ SWIGINTERN bool std_vector_Sl_unsigned_SS_long_Sg____bool__(std::vector< unsigne
 SWIGINTERN std::vector< unsigned long >::size_type std_vector_Sl_unsigned_SS_long_Sg____len__(std::vector< unsigned long > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< unsigned long,std::allocator< unsigned long > >());
-    }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v=std::vector< unsigned long,std::allocator< unsigned long > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5593,8 +5548,8 @@ SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vec
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
@@ -5604,8 +5559,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5615,8 +5570,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5626,8 +5581,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_1(std::vector< unsigned long > const *self,std::vector< unsigned long >::difference_type i){
@@ -5636,13 +5591,6 @@ SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigne
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_2(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__append(std::vector< unsigned long > *self,std::vector< unsigned long >::value_type const &x){
       self->push_back(x);
     }
@@ -5683,17 +5631,17 @@ const std::complex<double>&
 
 
 namespace swig {
-  template <> struct traits< std::complex<double> > {
+  template <> struct traits<std::complex<double> > {
     typedef value_category category;
     static const char* type_name() { return"std::complex<double>"; }
-  };
-  template <>  struct traits_asval< std::complex<double> > {
+  };  
+  template <>  struct traits_asval<std::complex<double> > {   
     typedef std::complex<double> value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
     }
   };
-  template <>  struct traits_from< std::complex<double> > {
+  template <>  struct traits_from<std::complex<double> > {
     typedef std::complex<double> value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_complex_Sl_double_Sg_  (val);
@@ -5703,7 +5651,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
+	template <>  struct traits<std::vector<std::complex< double >, std::allocator< std::complex< double > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::complex< double >" "," "std::allocator< std::complex< double > >" " >";
@@ -5723,20 +5671,24 @@ SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__(std::vector
 SWIGINTERN std::vector< std::complex< double > >::size_type std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__(std::vector< std::complex< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::complex< double >,std::allocator< std::complex< double > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v=std::vector< std::complex< double >,std::allocator< std::complex< double > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5745,8 +5697,8 @@ SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< dou
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
@@ -5756,8 +5708,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5767,8 +5719,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5778,8 +5730,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::complex< double > > const *self,std::vector< std::complex< double > >::difference_type i){
@@ -5788,13 +5740,6 @@ SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_S
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -5856,17 +5801,18 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #else
 	if (*alloc == SWIG_NEWOBJ) 
 #endif
-	{
-	  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-	  *alloc = SWIG_NEWOBJ;
-	} else {
+	  {
+	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
+	    *alloc = SWIG_NEWOBJ;
+	  }
+	else {
 	  *cptr = cstr;
 	  *alloc = SWIG_OLDOBJ;
 	}
       } else {
-	#if PY_VERSION_HEX>=0x03000000
-	assert(0); /* Should never reach here in Python 3 */
-	#endif
+        #if PY_VERSION_HEX>=0x03000000
+        assert(0); /* Should never reach here in Python 3 */
+        #endif
 	*cptr = SWIG_Python_str_AsChar(obj);
       }
     }
@@ -5876,30 +5822,6 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #endif
     return SWIG_OK;
   } else {
-#if defined(SWIG_PYTHON_2_UNICODE)
-#if PY_VERSION_HEX<0x03000000
-    if (PyUnicode_Check(obj)) {
-      char *cstr; Py_ssize_t len;
-      if (!alloc && cptr) {
-        return SWIG_RuntimeError;
-      }
-      obj = PyUnicode_AsUTF8String(obj);
-      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
-        if (cptr) {
-          if (alloc) *alloc = SWIG_NEWOBJ;
-          *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-        }
-        if (psize) *psize = len + 1;
-
-        Py_XDECREF(obj);
-        return SWIG_OK;
-      } else {
-        Py_XDECREF(obj);
-      }
-    }
-#endif
-#endif
-
     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
     if (pchar_descriptor) {
       void* vptr = 0;
@@ -5975,12 +5897,12 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
     } else {
 #if PY_VERSION_HEX >= 0x03000000
 #if PY_VERSION_HEX >= 0x03010000
-      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
+      return PyUnicode_DecodeUTF8(carray, static_cast< int >(size), "surrogateescape");
 #else
-      return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
 #endif
 #else
-      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyString_FromStringAndSize(carray, static_cast< int >(size));
 #endif
     }
   } else {
@@ -5997,17 +5919,17 @@ SWIG_From_std_string  (const std::string& s)
 
 
 namespace swig {
-  template <> struct traits< std::string > {
+  template <> struct traits<std::string > {
     typedef value_category category;
     static const char* type_name() { return"std::string"; }
-  };
-  template <>  struct traits_asval< std::string > {
+  };  
+  template <>  struct traits_asval<std::string > {   
     typedef std::string value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_string (obj, val);
     }
   };
-  template <>  struct traits_from< std::string > {
+  template <>  struct traits_from<std::string > {
     typedef std::string value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_string  (val);
@@ -6017,7 +5939,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
+	template <>  struct traits<std::vector<std::string, std::allocator< std::string > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
@@ -6037,20 +5959,24 @@ SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string >
 SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::string,std::allocator< std::string > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
-    }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v=std::vector< std::string,std::allocator< std::string > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6059,8 +5985,8 @@ SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
@@ -6070,8 +5996,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6081,8 +6007,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6092,8 +6018,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
@@ -6102,13 +6028,6 @@ SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_strin
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
       self->push_back(x);
     }
@@ -6387,14 +6306,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -6506,14 +6425,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -7057,14 +6976,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -7211,6 +7130,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< double >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  try {
+    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -7265,17 +7212,20 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
   std::vector< double >::difference_type arg3 ;
+  std::vector< double,std::allocator< double > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
@@ -7291,8 +7241,19 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
+  {
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -7302,8 +7263,10 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -7313,20 +7276,17 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
   std::vector< double >::difference_type arg3 ;
-  std::vector< double,std::allocator< double > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
@@ -7342,19 +7302,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
-  {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -7364,29 +7313,27 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7399,14 +7346,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7419,10 +7366,10 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -7432,8 +7379,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble1d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n"
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n");
   return 0;
 }
 
@@ -7514,9 +7461,6 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -7589,7 +7533,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble1d_t___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -7695,20 +7639,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7721,7 +7665,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7781,20 +7725,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7807,7 +7751,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7877,20 +7821,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7903,14 +7847,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble1d_t___setitem____SWIG_0(self, args);
@@ -7920,7 +7864,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -7949,34 +7893,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< double >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  try {
-    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_double(static_cast< double >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble1d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -8031,7 +7947,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble1d_t",&obj0)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble1d_t" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
@@ -8095,32 +8011,20 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  std::vector< double > *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:vdouble1d_t_swap",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble1d_t_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
-  }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
-  }
-  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
-  (arg1)->swap(*arg2);
+  (arg1)->clear();
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -8128,68 +8032,77 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  std::vector< double > *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< double >::iterator result;
+  PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_begin",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:vdouble1d_t_swap",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = (arg1)->begin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
-    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble1d_t_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
+  (arg1)->swap(*arg2);
+  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< double >::iterator result;
+  SwigValueWrapper< std::allocator< double > > result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_end",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = (arg1)->end();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
-    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+  result = ((std::vector< double > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< double >::reverse_iterator result;
+  std::vector< double >::iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_rbegin",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_begin",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = (arg1)->rbegin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
+  result = (arg1)->begin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -8197,22 +8110,22 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< double >::reverse_iterator result;
+  std::vector< double >::iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_rend",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_end",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = (arg1)->rend();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
+  result = (arg1)->end();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -8220,43 +8133,46 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  std::vector< double >::reverse_iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_rbegin",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
+  result = (arg1)->rbegin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
+    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< double > > result;
+  std::vector< double >::reverse_iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_rend",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = ((std::vector< double > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
+  result = (arg1)->rend();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
+    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
   return NULL;
@@ -8428,20 +8344,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -8454,7 +8370,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -8514,14 +8430,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -8540,7 +8456,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble1d_t__SWIG_1(self, args);
@@ -8733,20 +8649,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -8760,7 +8676,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -8894,20 +8810,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -8926,7 +8842,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -9129,6 +9045,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::vector< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -9183,17 +9127,20 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
   std::vector< std::vector< double > >::difference_type arg2 ;
   std::vector< std::vector< double > >::difference_type arg3 ;
+  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
@@ -9209,8 +9156,19 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
+  {
+    std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -9220,8 +9178,10 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -9231,20 +9191,17 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
   std::vector< std::vector< double > >::difference_type arg2 ;
   std::vector< std::vector< double > >::difference_type arg3 ;
-  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
@@ -9260,19 +9217,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
-  {
-    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
+    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -9282,29 +9228,27 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9317,14 +9261,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9337,10 +9281,10 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -9350,8 +9294,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble2d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n");
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n");
   return 0;
 }
 
@@ -9432,9 +9376,6 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -9507,7 +9448,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
+    std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
@@ -9613,20 +9554,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9639,7 +9580,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9691,7 +9632,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_1(PyObject *SWIGUNUSEDP
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
   
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -9699,20 +9640,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9725,7 +9666,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9773,7 +9714,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_2(PyObject *SWIGUNUSEDP
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -9800,20 +9741,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9826,14 +9767,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_0(self, args);
@@ -9843,7 +9784,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -9851,7 +9792,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_2(self, args);
@@ -9870,34 +9811,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::vector< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -9915,7 +9828,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), Py
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -9957,7 +9870,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble2d_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
+    std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble2d_t" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
@@ -10021,6 +9934,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -10054,6 +9988,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >::allocator_type(static_cast< const std::vector< std::vector< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -10146,49 +10102,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >::allocator_type(static_cast< const std::vector< std::vector< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > >::size_type arg1 ;
@@ -10354,20 +10267,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -10380,7 +10293,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -10424,7 +10337,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_3(PyObject *SWIGUNUSEDPARM(self
   } 
   arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vdouble2d_t" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10445,14 +10358,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -10471,7 +10384,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble2d_t__SWIG_1(self, args);
@@ -10484,7 +10397,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
       _v = SWIG_CheckState(res);
     }
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_new_vdouble2d_t__SWIG_3(self, args);
@@ -10520,7 +10433,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_push_back(PyObject *SWIGUNUSEDPARM(self),
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10555,7 +10468,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_front(PyObject *SWIGUNUSEDPARM(self), PyO
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -10577,7 +10490,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_back(PyObject *SWIGUNUSEDPARM(self), PyOb
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -10610,7 +10523,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_assign(PyObject *SWIGUNUSEDPARM(self), Py
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10656,7 +10569,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10677,20 +10590,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -10704,7 +10617,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -10712,7 +10625,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_resize__SWIG_1(self, args);
@@ -10763,7 +10676,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(s
     }
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10825,7 +10738,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -10846,27 +10759,27 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_insert__SWIG_0(self, args);
@@ -10876,7 +10789,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -10888,7 +10801,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
             return _wrap_vdouble2d_t_insert__SWIG_1(self, args);
@@ -11077,6 +10990,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< int >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  try {
+    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -11131,17 +11072,20 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   std::vector< int >::difference_type arg2 ;
   std::vector< int >::difference_type arg3 ;
+  std::vector< int,std::allocator< int > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
@@ -11157,8 +11101,19 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< int >::difference_type >(val3);
+  {
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -11168,8 +11123,10 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -11179,20 +11136,17 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   std::vector< int >::difference_type arg2 ;
   std::vector< int >::difference_type arg3 ;
-  std::vector< int,std::allocator< int > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
@@ -11208,19 +11162,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< int >::difference_type >(val3);
-  {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
+    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -11230,29 +11173,27 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11265,14 +11206,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11285,10 +11226,10 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<int,std::allocator< int > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -11298,8 +11239,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_integer_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n"
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n");
   return 0;
 }
 
@@ -11380,9 +11321,6 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -11455,7 +11393,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_integer_t___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
@@ -11561,20 +11499,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11587,7 +11525,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11647,20 +11585,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11673,7 +11611,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11743,20 +11681,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11769,14 +11707,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<int,std::allocator< int > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_integer_t___setitem____SWIG_0(self, args);
@@ -11786,7 +11724,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11815,34 +11753,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< int >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  try {
-    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_integer_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -11897,7 +11807,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_integer_t",&obj0)) SWIG_fail;
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_integer_t" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
@@ -11961,6 +11871,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -11994,6 +11925,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< int > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -12086,49 +12039,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< int > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  result = ((std::vector< int > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int >::size_type arg1 ;
@@ -12294,20 +12204,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12320,7 +12230,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12380,14 +12290,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -12406,7 +12316,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_integer_t__SWIG_1(self, args);
@@ -12599,20 +12509,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12626,7 +12536,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12760,20 +12670,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12792,7 +12702,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12995,6 +12905,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< unsigned long >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  try {
+    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -13049,17 +12987,20 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
   std::vector< unsigned long >::difference_type arg2 ;
   std::vector< unsigned long >::difference_type arg3 ;
+  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
@@ -13075,8 +13016,19 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
+  {
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -13086,8 +13038,10 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -13097,20 +13051,17 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
   std::vector< unsigned long >::difference_type arg2 ;
   std::vector< unsigned long >::difference_type arg3 ;
-  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
@@ -13126,19 +13077,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
-  {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
+    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -13148,29 +13088,27 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13183,14 +13121,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13203,10 +13141,10 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -13216,8 +13154,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n");
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n");
   return 0;
 }
 
@@ -13298,9 +13236,6 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_0(PyObject *SW
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -13373,7 +13308,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *SW
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_longinteger_t___setitem__" "', argument " "3"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
@@ -13479,20 +13414,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13505,7 +13440,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13565,20 +13500,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13591,7 +13526,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13661,20 +13596,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13687,14 +13622,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_longinteger_t___setitem____SWIG_0(self, args);
@@ -13704,7 +13639,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13720,44 +13655,16 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
           return _wrap_vector_longinteger_t___setitem____SWIG_2(self, args);
         }
       }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
-    "    std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
-    "    std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< unsigned long >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  try {
-    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+    }
   }
   
-  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
-  return resultobj;
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+    "    std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+    "    std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
+  return 0;
 }
 
 
@@ -13815,7 +13722,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_1(PyObject *SWIGUNUSED
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_longinteger_t",&obj0)) SWIG_fail;
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_longinteger_t" "', argument " "1"" of type '" "std::vector< unsigned long > const &""'"); 
@@ -13879,6 +13786,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -13912,6 +13840,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< unsigned long > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -14004,49 +13954,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< unsigned long > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long >::size_type arg1 ;
@@ -14212,20 +14119,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -14238,7 +14145,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -14298,14 +14205,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -14324,7 +14231,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *ar
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_longinteger_t__SWIG_1(self, args);
@@ -14517,20 +14424,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14544,7 +14451,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14678,20 +14585,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -14710,7 +14617,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -14913,6 +14820,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::complex< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -14967,17 +14902,20 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_0(PyObject *SWIGU
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   std::vector< std::complex< double > >::difference_type arg2 ;
   std::vector< std::complex< double > >::difference_type arg3 ;
+  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
@@ -14993,8 +14931,19 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_0(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
+  {
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -15004,8 +14953,10 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_0(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -15015,20 +14966,17 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGU
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   std::vector< std::complex< double > >::difference_type arg2 ;
   std::vector< std::complex< double > >::difference_type arg3 ;
-  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
@@ -15044,19 +14992,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
-  {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
+    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -15066,29 +15003,27 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15101,14 +15036,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15121,10 +15056,10 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -15134,8 +15069,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_complex_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n");
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n");
   return 0;
 }
 
@@ -15216,9 +15151,6 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -15291,7 +15223,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_complex_t___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
@@ -15397,20 +15329,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15423,7 +15355,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15483,20 +15415,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15509,7 +15441,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15579,20 +15511,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15605,14 +15537,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_complex_t___setitem____SWIG_0(self, args);
@@ -15622,7 +15554,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15651,34 +15583,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_complex_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -15733,7 +15637,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_complex_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_complex_t" "', argument " "1"" of type '" "std::vector< std::complex< double > > const &""'"); 
@@ -15797,6 +15701,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -15830,30 +15755,29 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::iterator result;
+  SwigValueWrapper< std::allocator< std::complex< double > > > result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_begin",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_begin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = (arg1)->begin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
-    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vector_complex_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   void *argp1 = 0 ;
@@ -15861,13 +15785,13 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_end(PyObject *SWIGUNUSEDPARM(self),
   PyObject * obj0 = 0 ;
   std::vector< std::complex< double > >::iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_end",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_begin",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_end" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_begin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = (arg1)->end();
+  result = (arg1)->begin();
   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
@@ -15876,45 +15800,22 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::reverse_iterator result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_rbegin",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_rbegin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = (arg1)->rbegin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
-    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_complex_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vector_complex_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::reverse_iterator result;
+  std::vector< std::complex< double > >::iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_rend",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_end",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_rend" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_end" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = (arg1)->rend();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
+  result = (arg1)->end();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -15922,43 +15823,46 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vector_complex_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  std::vector< std::complex< double > >::reverse_iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_rbegin",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_rbegin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
+  result = (arg1)->rbegin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
+    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vector_complex_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::complex< double > > > result;
+  std::vector< std::complex< double > >::reverse_iterator result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_rend",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_rend" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
+  result = (arg1)->rend();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
+    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
   return NULL;
@@ -16130,20 +16034,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16156,7 +16060,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16216,14 +16120,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -16242,7 +16146,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_complex_t__SWIG_1(self, args);
@@ -16435,20 +16339,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16462,7 +16366,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16596,20 +16500,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16628,7 +16532,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16831,6 +16735,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::string >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  try {
+    result = std_vector_Sl_std_string_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -16885,17 +16817,20 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_0(PyObject *SWIGUN
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
   std::vector< std::string >::difference_type arg2 ;
   std::vector< std::string >::difference_type arg3 ;
+  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
@@ -16911,8 +16846,19 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_0(PyObject *SWIGUN
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
+  {
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -16922,8 +16868,10 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_0(PyObject *SWIGUN
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -16933,20 +16881,17 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUN
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
   std::vector< std::string >::difference_type arg2 ;
   std::vector< std::string >::difference_type arg3 ;
-  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
@@ -16962,19 +16907,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUN
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
-  {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
+    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -16984,29 +16918,27 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUN
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17019,14 +16951,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_string_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_string_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17039,10 +16971,10 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::string,std::allocator< std::string > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_string_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_string_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -17052,8 +16984,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_string_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n"
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n");
   return 0;
 }
 
@@ -17134,9 +17066,6 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_0(PyObject *SWIGUNU
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -17209,7 +17138,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *SWIGUNU
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_t___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -17315,20 +17244,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17341,7 +17270,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17401,20 +17330,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17427,7 +17356,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17502,20 +17431,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17528,14 +17457,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::string,std::allocator< std::string > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_string_t___setitem____SWIG_0(self, args);
@@ -17545,7 +17474,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17572,34 +17501,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::string >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  try {
-    result = std_vector_Sl_std_string_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_string_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -17659,7 +17560,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_1(PyObject *SWIGUNUSEDPARM(
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_string_t" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
@@ -17723,6 +17624,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -17756,6 +17678,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::string > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  result = ((std::vector< std::string > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -17848,49 +17792,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::string > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  result = ((std::vector< std::string > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string >::size_type arg1 ;
@@ -18056,20 +17957,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -18082,7 +17983,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args)
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -18147,14 +18048,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -18173,7 +18074,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_string_t__SWIG_1(self, args);
@@ -18379,20 +18280,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18406,7 +18307,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18548,20 +18449,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -18578,7 +18479,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -19007,7 +18908,7 @@ SWIGINTERN PyObject *_wrap_IMinimizer_getValueOfVariablesAtMinimum(PyObject *SWI
   }
   arg1 = reinterpret_cast< IMinimizer * >(argp1);
   result = ((IMinimizer const *)arg1)->getValueOfVariablesAtMinimum();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -19060,7 +18961,7 @@ SWIGINTERN PyObject *_wrap_IMinimizer_getErrorOfVariables(PyObject *SWIGUNUSEDPA
   }
   arg1 = reinterpret_cast< IMinimizer * >(argp1);
   result = ((IMinimizer const *)arg1)->getErrorOfVariables();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -19176,14 +19077,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IMinimizer_getOptions(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -19487,14 +19388,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IChiSquaredModule_setChiSquaredFunction(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -19580,14 +19481,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IChiSquaredModule_getIntensityNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -20656,14 +20557,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IntensityNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -20921,14 +20822,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IntensityScaleAndShiftNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -21207,14 +21108,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ISquaredFunction_calculateSquaredError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -21439,14 +21340,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SquaredFunctionDefault_calculateSquaredError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -22062,14 +21963,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ChiSquaredModule(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -22338,14 +22239,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FitObject(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -22639,14 +22540,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitObject_prepareFitElements(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -23139,14 +23040,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FitParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -23650,14 +23551,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_addSimulationAndRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -23925,14 +23826,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_addFitParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24274,14 +24175,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_setMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24477,7 +24378,7 @@ SWIGINTERN PyObject *_wrap_FitSuite_setParametersFixed(PyObject *SWIGUNUSEDPARM(
   }
   arg1 = reinterpret_cast< FitSuite * >(argp1);
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuite_setParametersFixed" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -24599,14 +24500,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24698,14 +24599,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getSimulationData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24797,14 +24698,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getChiSquaredMap(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25135,14 +25036,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getRealOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25234,14 +25135,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getSimulationOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25333,14 +25234,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getChiSquaredOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25540,14 +25441,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_add(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25732,14 +25633,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25831,14 +25732,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getSimulationData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25930,14 +25831,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getChiSquaredMap(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26306,14 +26207,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_addParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26468,14 +26369,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_getParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26562,7 +26463,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues__SWIG_1(PyObject *SWIGUN
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -26583,14 +26484,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26614,7 +26515,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues(PyObject *self, PyObject
     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitSuiteParameters, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_FitSuiteParameters_setValues__SWIG_1(self, args);
@@ -26646,7 +26547,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_getValues(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   result = ((FitSuiteParameters const *)arg1)->getValues();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -26670,7 +26571,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setErrors(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setErrors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -26705,7 +26606,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_getErrors(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   result = ((FitSuiteParameters const *)arg1)->getErrors();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -26809,14 +26710,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_begin(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26893,14 +26794,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_end(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27056,14 +26957,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_valuesAreDifferrent(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27195,7 +27096,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setParametersFixed(PyObject *SWIGU
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setParametersFixed" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -27285,14 +27186,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27518,14 +27419,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_sinc(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27723,14 +27624,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J0(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27793,14 +27694,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27863,14 +27764,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1c(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27971,7 +27872,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"OO:FastFourierTransform",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FastFourierTransform" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -27997,14 +27898,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -28024,7 +27925,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args)
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -28058,7 +27959,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
   
   if (!PyArg_ParseTuple(args,(char *)"OO:ConvolveFFT",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolveFFT" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -28069,7 +27970,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
     arg1 = ptr;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolveFFT" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -28632,14 +28533,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_setValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -28857,14 +28758,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_getValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -29079,14 +28980,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_addValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -29468,14 +29369,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerFactory_createMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -29726,14 +29627,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30043,14 +29944,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30215,10 +30116,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_VARARGS, (char *)"vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_VARARGS, (char *)"vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___len__", _wrap_vdouble1d_t___len__, METH_VARARGS, (char *)"vdouble1d_t___len__(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t___getslice__", _wrap_vdouble1d_t___getslice__, METH_VARARGS, (char *)"vdouble1d_t___getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"},
 	 { (char *)"vdouble1d_t___setslice__", _wrap_vdouble1d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
-		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, (char *)"vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
 	 { (char *)"vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30234,17 +30136,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
 		""},
-	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t_append", _wrap_vdouble1d_t_append, METH_VARARGS, (char *)"vdouble1d_t_append(vdouble1d_t self, std::vector< double >::value_type const & x)"},
 	 { (char *)"vdouble1d_t_empty", _wrap_vdouble1d_t_empty, METH_VARARGS, (char *)"vdouble1d_t_empty(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t_size", _wrap_vdouble1d_t_size, METH_VARARGS, (char *)"vdouble1d_t_size(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_swap", _wrap_vdouble1d_t_swap, METH_VARARGS, (char *)"vdouble1d_t_swap(vdouble1d_t self, vdouble1d_t v)"},
+	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_begin", _wrap_vdouble1d_t_begin, METH_VARARGS, (char *)"vdouble1d_t_begin(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_end", _wrap_vdouble1d_t_end, METH_VARARGS, (char *)"vdouble1d_t_end(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_rbegin", _wrap_vdouble1d_t_rbegin, METH_VARARGS, (char *)"vdouble1d_t_rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
 	 { (char *)"vdouble1d_t_rend", _wrap_vdouble1d_t_rend, METH_VARARGS, (char *)"vdouble1d_t_rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
-	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
-	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_pop_back", _wrap_vdouble1d_t_pop_back, METH_VARARGS, (char *)"vdouble1d_t_pop_back(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_erase", _wrap_vdouble1d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< double >::iterator pos) -> std::vector< double >::iterator\n"
@@ -30276,10 +30177,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble2d_t___nonzero__", _wrap_vdouble2d_t___nonzero__, METH_VARARGS, (char *)"vdouble2d_t___nonzero__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___bool__", _wrap_vdouble2d_t___bool__, METH_VARARGS, (char *)"vdouble2d_t___bool__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___len__", _wrap_vdouble2d_t___len__, METH_VARARGS, (char *)"vdouble2d_t___len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t___getslice__", _wrap_vdouble2d_t___getslice__, METH_VARARGS, (char *)"vdouble2d_t___getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"},
 	 { (char *)"vdouble2d_t___setslice__", _wrap_vdouble2d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
-		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, (char *)"vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
 	 { (char *)"vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30295,17 +30197,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
 		""},
-	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t_append", _wrap_vdouble2d_t_append, METH_VARARGS, (char *)"vdouble2d_t_append(vdouble2d_t self, vdouble1d_t x)"},
 	 { (char *)"vdouble2d_t_empty", _wrap_vdouble2d_t_empty, METH_VARARGS, (char *)"vdouble2d_t_empty(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t_size", _wrap_vdouble2d_t_size, METH_VARARGS, (char *)"vdouble2d_t_size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_swap", _wrap_vdouble2d_t_swap, METH_VARARGS, (char *)"vdouble2d_t_swap(vdouble2d_t self, vdouble2d_t v)"},
+	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_begin", _wrap_vdouble2d_t_begin, METH_VARARGS, (char *)"vdouble2d_t_begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_end", _wrap_vdouble2d_t_end, METH_VARARGS, (char *)"vdouble2d_t_end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_rbegin", _wrap_vdouble2d_t_rbegin, METH_VARARGS, (char *)"vdouble2d_t_rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
 	 { (char *)"vdouble2d_t_rend", _wrap_vdouble2d_t_rend, METH_VARARGS, (char *)"vdouble2d_t_rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
-	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
-	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_pop_back", _wrap_vdouble2d_t_pop_back, METH_VARARGS, (char *)"vdouble2d_t_pop_back(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_erase", _wrap_vdouble2d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator\n"
@@ -30337,10 +30238,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_integer_t___nonzero__", _wrap_vector_integer_t___nonzero__, METH_VARARGS, (char *)"vector_integer_t___nonzero__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___bool__", _wrap_vector_integer_t___bool__, METH_VARARGS, (char *)"vector_integer_t___bool__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___len__", _wrap_vector_integer_t___len__, METH_VARARGS, (char *)"vector_integer_t___len__(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t___getslice__", _wrap_vector_integer_t___getslice__, METH_VARARGS, (char *)"vector_integer_t___getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"},
 	 { (char *)"vector_integer_t___setslice__", _wrap_vector_integer_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
-		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
 		""},
 	 { (char *)"vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, (char *)"vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
 	 { (char *)"vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30356,17 +30258,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t_append", _wrap_vector_integer_t_append, METH_VARARGS, (char *)"vector_integer_t_append(vector_integer_t self, std::vector< int >::value_type const & x)"},
 	 { (char *)"vector_integer_t_empty", _wrap_vector_integer_t_empty, METH_VARARGS, (char *)"vector_integer_t_empty(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t_size", _wrap_vector_integer_t_size, METH_VARARGS, (char *)"vector_integer_t_size(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_swap", _wrap_vector_integer_t_swap, METH_VARARGS, (char *)"vector_integer_t_swap(vector_integer_t self, vector_integer_t v)"},
+	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_begin", _wrap_vector_integer_t_begin, METH_VARARGS, (char *)"vector_integer_t_begin(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_end", _wrap_vector_integer_t_end, METH_VARARGS, (char *)"vector_integer_t_end(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_rbegin", _wrap_vector_integer_t_rbegin, METH_VARARGS, (char *)"vector_integer_t_rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
 	 { (char *)"vector_integer_t_rend", _wrap_vector_integer_t_rend, METH_VARARGS, (char *)"vector_integer_t_rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
-	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
-	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_pop_back", _wrap_vector_integer_t_pop_back, METH_VARARGS, (char *)"vector_integer_t_pop_back(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_erase", _wrap_vector_integer_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< int >::iterator pos) -> std::vector< int >::iterator\n"
@@ -30398,10 +30299,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_longinteger_t___nonzero__", _wrap_vector_longinteger_t___nonzero__, METH_VARARGS, (char *)"vector_longinteger_t___nonzero__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___bool__", _wrap_vector_longinteger_t___bool__, METH_VARARGS, (char *)"vector_longinteger_t___bool__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___len__", _wrap_vector_longinteger_t___len__, METH_VARARGS, (char *)"vector_longinteger_t___len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t___getslice__", _wrap_vector_longinteger_t___getslice__, METH_VARARGS, (char *)"vector_longinteger_t___getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"},
 	 { (char *)"vector_longinteger_t___setslice__", _wrap_vector_longinteger_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
-		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
 		""},
 	 { (char *)"vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, (char *)"vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
 	 { (char *)"vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30417,17 +30319,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t_append", _wrap_vector_longinteger_t_append, METH_VARARGS, (char *)"vector_longinteger_t_append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"},
 	 { (char *)"vector_longinteger_t_empty", _wrap_vector_longinteger_t_empty, METH_VARARGS, (char *)"vector_longinteger_t_empty(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t_size", _wrap_vector_longinteger_t_size, METH_VARARGS, (char *)"vector_longinteger_t_size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_swap", _wrap_vector_longinteger_t_swap, METH_VARARGS, (char *)"vector_longinteger_t_swap(vector_longinteger_t self, vector_longinteger_t v)"},
+	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_begin", _wrap_vector_longinteger_t_begin, METH_VARARGS, (char *)"vector_longinteger_t_begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_end", _wrap_vector_longinteger_t_end, METH_VARARGS, (char *)"vector_longinteger_t_end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_rbegin", _wrap_vector_longinteger_t_rbegin, METH_VARARGS, (char *)"vector_longinteger_t_rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
 	 { (char *)"vector_longinteger_t_rend", _wrap_vector_longinteger_t_rend, METH_VARARGS, (char *)"vector_longinteger_t_rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
-	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
-	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_pop_back", _wrap_vector_longinteger_t_pop_back, METH_VARARGS, (char *)"vector_longinteger_t_pop_back(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_erase", _wrap_vector_longinteger_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator\n"
@@ -30459,10 +30360,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_complex_t___nonzero__", _wrap_vector_complex_t___nonzero__, METH_VARARGS, (char *)"vector_complex_t___nonzero__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___bool__", _wrap_vector_complex_t___bool__, METH_VARARGS, (char *)"vector_complex_t___bool__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___len__", _wrap_vector_complex_t___len__, METH_VARARGS, (char *)"vector_complex_t___len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t___getslice__", _wrap_vector_complex_t___getslice__, METH_VARARGS, (char *)"vector_complex_t___getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"},
 	 { (char *)"vector_complex_t___setslice__", _wrap_vector_complex_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
-		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, (char *)"vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
 	 { (char *)"vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30478,17 +30380,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t_append", _wrap_vector_complex_t_append, METH_VARARGS, (char *)"vector_complex_t_append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"},
 	 { (char *)"vector_complex_t_empty", _wrap_vector_complex_t_empty, METH_VARARGS, (char *)"vector_complex_t_empty(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t_size", _wrap_vector_complex_t_size, METH_VARARGS, (char *)"vector_complex_t_size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_swap", _wrap_vector_complex_t_swap, METH_VARARGS, (char *)"vector_complex_t_swap(vector_complex_t self, vector_complex_t v)"},
+	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_begin", _wrap_vector_complex_t_begin, METH_VARARGS, (char *)"vector_complex_t_begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_end", _wrap_vector_complex_t_end, METH_VARARGS, (char *)"vector_complex_t_end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_rbegin", _wrap_vector_complex_t_rbegin, METH_VARARGS, (char *)"vector_complex_t_rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
 	 { (char *)"vector_complex_t_rend", _wrap_vector_complex_t_rend, METH_VARARGS, (char *)"vector_complex_t_rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
-	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
-	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_pop_back", _wrap_vector_complex_t_pop_back, METH_VARARGS, (char *)"vector_complex_t_pop_back(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_erase", _wrap_vector_complex_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator\n"
@@ -30520,10 +30421,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_string_t___nonzero__", _wrap_vector_string_t___nonzero__, METH_VARARGS, (char *)"vector_string_t___nonzero__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___bool__", _wrap_vector_string_t___bool__, METH_VARARGS, (char *)"vector_string_t___bool__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___len__", _wrap_vector_string_t___len__, METH_VARARGS, (char *)"vector_string_t___len__(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t___getslice__", _wrap_vector_string_t___getslice__, METH_VARARGS, (char *)"vector_string_t___getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"},
 	 { (char *)"vector_string_t___setslice__", _wrap_vector_string_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
-		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
 		""},
 	 { (char *)"vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, (char *)"vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
 	 { (char *)"vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -30539,17 +30441,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t_append", _wrap_vector_string_t_append, METH_VARARGS, (char *)"vector_string_t_append(vector_string_t self, std::vector< std::string >::value_type const & x)"},
 	 { (char *)"vector_string_t_empty", _wrap_vector_string_t_empty, METH_VARARGS, (char *)"vector_string_t_empty(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t_size", _wrap_vector_string_t_size, METH_VARARGS, (char *)"vector_string_t_size(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
 	 { (char *)"vector_string_t_swap", _wrap_vector_string_t_swap, METH_VARARGS, (char *)"vector_string_t_swap(vector_string_t self, vector_string_t v)"},
+	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_begin", _wrap_vector_string_t_begin, METH_VARARGS, (char *)"vector_string_t_begin(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_end", _wrap_vector_string_t_end, METH_VARARGS, (char *)"vector_string_t_end(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_rbegin", _wrap_vector_string_t_rbegin, METH_VARARGS, (char *)"vector_string_t_rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
 	 { (char *)"vector_string_t_rend", _wrap_vector_string_t_rend, METH_VARARGS, (char *)"vector_string_t_rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
-	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
-	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_pop_back", _wrap_vector_string_t_pop_back, METH_VARARGS, (char *)"vector_string_t_pop_back(vector_string_t self)"},
 	 { (char *)"vector_string_t_erase", _wrap_vector_string_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator\n"
@@ -32810,19 +32711,10 @@ extern "C" {
         0,                                  /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-        0,                                  /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-        0,                                  /* tp_finalize */
+        0,                                  /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-        0,                                  /* tp_allocs */
-        0,                                  /* tp_frees */
-        0,                                  /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-        0,                                  /* tp_prev */
-#endif
-        0                                   /* tp_next */
+        0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
       };
       varlink_type = tmp;
diff --git a/Fit/PythonAPI/libBornAgainFit_wrap.h b/Fit/PythonAPI/libBornAgainFit_wrap.h
index 718336e1d7d8207a58ce326d8315db2f22642a5d..1a057689d5735ec407584282287e0196bb5507d7 100644
--- a/Fit/PythonAPI/libBornAgainFit_wrap.h
+++ b/Fit/PythonAPI/libBornAgainFit_wrap.h
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * 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
diff --git a/dev-tools/swig/doxygen_core.i b/dev-tools/swig/doxygen_core.i
index f61d1e5ecd9c3a2cc8a713193073e6724725beef..009f13cca57b2108dc6fb0531e7c0ba9397ac205 100644
--- a/dev-tools/swig/doxygen_core.i
+++ b/dev-tools/swig/doxygen_core.i
@@ -2257,7 +2257,7 @@ Decorates a formfactor with a constant factor.
 C++ includes: FormFactorDecoratorFactor.h
 ";
 
-%feature("docstring")  FormFactorDecoratorFactor::FormFactorDecoratorFactor "FormFactorDecoratorFactor::FormFactorDecoratorFactor(const IFormFactor &form_factor, const complex_t &factor)
+%feature("docstring")  FormFactorDecoratorFactor::FormFactorDecoratorFactor "FormFactorDecoratorFactor::FormFactorDecoratorFactor(const IFormFactor &form_factor, const complex_t factor)
 ";
 
 %feature("docstring")  FormFactorDecoratorFactor::~FormFactorDecoratorFactor "virtual FormFactorDecoratorFactor::~FormFactorDecoratorFactor()
@@ -5009,7 +5009,7 @@ An homogeneous material with magnetization.
 C++ includes: HomogeneousMagneticMaterial.h
 ";
 
-%feature("docstring")  HomogeneousMagneticMaterial::HomogeneousMagneticMaterial "HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(const std::string &name, const complex_t &refractive_index, const kvector_t magnetic_field)
+%feature("docstring")  HomogeneousMagneticMaterial::HomogeneousMagneticMaterial "HomogeneousMagneticMaterial::HomogeneousMagneticMaterial(const std::string &name, const complex_t refractive_index, const kvector_t magnetic_field)
 
 Constructs a material with  name,  refractive_index and  magnetic_field
 ";
@@ -5058,7 +5058,7 @@ An homogeneous material with a refractive index.
 C++ includes: HomogeneousMaterial.h
 ";
 
-%feature("docstring")  HomogeneousMaterial::HomogeneousMaterial "HomogeneousMaterial::HomogeneousMaterial(const std::string &name, const complex_t &refractive_index)
+%feature("docstring")  HomogeneousMaterial::HomogeneousMaterial "HomogeneousMaterial::HomogeneousMaterial(const std::string &name, const complex_t refractive_index)
 
 Constructs a material with  name and  refractive_index. 
 ";
@@ -5081,7 +5081,7 @@ Clone.
 Return refractive index. 
 ";
 
-%feature("docstring")  HomogeneousMaterial::setRefractiveIndex "void HomogeneousMaterial::setRefractiveIndex(const complex_t &refractive_index)
+%feature("docstring")  HomogeneousMaterial::setRefractiveIndex "void HomogeneousMaterial::setRefractiveIndex(const complex_t refractive_index)
 
 Set refractive index. 
 ";
diff --git a/dev-tools/swig/doxygen_fit.i b/dev-tools/swig/doxygen_fit.i
index a5c8c95547cf012a0cf8d6b43627d6cbbcab0f61..2f8d92c3ffcf89bd9ab44b95f9b3131dd00d840e 100644
--- a/dev-tools/swig/doxygen_fit.i
+++ b/dev-tools/swig/doxygen_fit.i
@@ -2048,14 +2048,11 @@ run core functional tests with given name
 // File: StandardFitsFactory_8h.xml
 
 
-// File: dir_d0c8f8fb9032c27878972645c4679f14.xml
+// File: dir_892d84e8d1420bf45a9053cf0eede900.xml
 
 
-// File: dir_befad91b6aded329d87ab1464acca32e.xml
+// File: dir_4e6c9d4e290828461655ecdd2f34719c.xml
 
 
-// File: dir_abb56b21da33f65f621bf551b5073624.xml
-
-
-// File: dir_8c00782886f69f4c4190b8932144dcd3.xml
+// File: dir_f0d58a7b25b35daab22ce6e2bfb078e9.xml