diff --git a/.gitignore b/.gitignore
index 0f00991a30dccbb2df8c9516c3b144a8d1b1ed0a..31483ed97ab9b41872a93a4b5cc96e90c629b27b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ build-rel/
 .*~
 *.user
 *.pyc
+*.ipynb_checkpoints
diff --git a/include/curves/linear_variable.h b/include/curves/linear_variable.h
index 79882b674fd222cbaea6a9a5175b9b811023d1bb..7dc48684e02734d50d121e82868a4047cb5647aa 100644
--- a/include/curves/linear_variable.h
+++ b/include/curves/linear_variable.h
@@ -12,6 +12,8 @@
 
 #include "curve_abc.h"
 #include "bezier_curve.h"
+#include "serialization/archive.hpp"
+#include "serialization/eigen-matrix.hpp"
 
 #include "MathDefs.h"
 
@@ -23,7 +25,7 @@
 namespace curves
 {
 template <typename Numeric=double, bool Safe=true>
-struct linear_variable
+struct linear_variable : public serialization::Serializable
 {
     typedef Eigen::Matrix<Numeric, Eigen::Dynamic, 1> vector_x_t;
     typedef Eigen::Matrix<Numeric, Eigen::Dynamic, Eigen::Dynamic> matrix_x_t;
@@ -94,10 +96,29 @@ struct linear_variable
 
     std::size_t size() const {return zero ? 0 : std::max(B_.cols(), c_.size()) ;}
 
+    Numeric norm() const
+    {
+        return isZero() ? 0 : (B_.norm() + c_.norm());
+    }
+
     const matrix_x_t& B() const {return B_;}
     const vector_x_t& c () const {return c_;}
     bool isZero () const {return zero;}
 
+
+    // Serialization of the class
+    friend class boost::serialization::access;
+
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+      if (version) {
+        // Do something depending on version ?
+      }
+      ar& boost::serialization::make_nvp("B_", B_);
+      ar& boost::serialization::make_nvp("c_", c_);
+      ar& boost::serialization::make_nvp("zero", zero);
+    }
+
 private:
     matrix_x_t B_;
     vector_x_t c_;
diff --git a/include/curves/optimization/definitions.h b/include/curves/optimization/definitions.h
index f996d0d372387e6fc76da2520dc9fe8243d12cda..52143e129851fdea2a8493e424b456f8bdec5c11 100644
--- a/include/curves/optimization/definitions.h
+++ b/include/curves/optimization/definitions.h
@@ -47,7 +47,7 @@ struct quadratic_problem
 
 
 template<typename Point, typename Numeric>
-struct problem_definition
+struct problem_definition : public curve_constraints<Point>
 {
     typedef Point  point_t;
     typedef Numeric  num_t;
@@ -60,20 +60,29 @@ struct problem_definition
     typedef typename T_vector_x_t::const_iterator CIT_vector_x_t;
 
     problem_definition(const int dim)
-        : flag(NONE)
-        , start(point_t::Zero(dim))
-        , end(point_t::Zero(dim))
-        , curveConstraints(dim)
+        : curve_constraints_t(dim)
+        , flag(NONE)
+        , init_pos(point_t::Zero(dim))
+        , end_pos(point_t::Zero(dim))
         , degree(5)
         , totalTime(1.)
         , splitTimes_(vector_x_t::Zero(0))
         , dim_(dim){}
 
+    problem_definition(const curve_constraints_t& parent)
+        : curve_constraints_t(parent)
+        , flag(NONE)
+        , init_pos(point_t::Zero(parent.dim_))
+        , end_pos(point_t::Zero(parent.dim_))
+        , degree(5)
+        , totalTime(1.)
+        , splitTimes_(vector_x_t::Zero(0))
+        , dim_(parent.dim_){}
+
 
     constraint_flag flag;
-    point_t start;
-    point_t end;
-    curve_constraints_t curveConstraints;
+    point_t init_pos;
+    point_t end_pos;
     std::size_t degree;
     num_t totalTime;
     vector_x_t splitTimes_;
diff --git a/include/curves/optimization/details.h b/include/curves/optimization/details.h
index 042b1ae77f601a25bd0c1c32b2bbed9a3aa1782b..f3691b6920bde0643e54f2a965c4c05b487fad5a 100644
--- a/include/curves/optimization/details.h
+++ b/include/curves/optimization/details.h
@@ -103,7 +103,6 @@ problem_data<Point, Numeric, Safe> setup_control_points(const problem_definition
     typedef linear_variable<Numeric>     var_t;
     typedef problem_data<Point, Numeric> problem_data_t;
 
-    const curve_constraints<Point>& constraints = pDef.curveConstraints;
     const std::size_t& degree = pDef.degree;
     const constraint_flag& flag = pDef.flag;
 
@@ -120,26 +119,26 @@ problem_data<Point, Numeric, Safe> setup_control_points(const problem_definition
     std::size_t i =0;
     if(flag & INIT_POS)
     {
-        variables_.push_back(var_t(pDef.start));
+        variables_.push_back(var_t(pDef.init_pos));
         ++numConstants;
         ++i;
         if(flag & INIT_VEL)
         {
-            point_t vel = pDef.start + (constraints.init_vel / (num_t)degree) / pDef.totalTime;
+            point_t vel = pDef.init_pos + (pDef.init_vel / (num_t)degree) / pDef.totalTime;
             variables_.push_back(var_t(vel));
             ++numConstants;
             ++i;
             if(flag & INIT_ACC)
             {
-                point_t acc = (constraints.init_acc / (num_t)(degree * (degree-1)))
+                point_t acc = (pDef.init_acc / (num_t)(degree * (degree-1)))
                         / (pDef.totalTime *  pDef.totalTime)
-                        + 2* vel- pDef.start;;
+                        + 2* vel- pDef.init_pos;;
                 variables_.push_back(var_t(acc));
                 ++numConstants;
                 ++i;
                 if(flag & INIT_JERK){
-                  point_t jerk = constraints.init_jerk*pDef.totalTime*pDef.totalTime*pDef.totalTime/(num_t)(degree*(degree-1)*(degree-2))
-                  + 3*acc -3*vel +pDef.start;
+                  point_t jerk = pDef.init_jerk*pDef.totalTime*pDef.totalTime*pDef.totalTime/(num_t)(degree*(degree-1)*(degree-2))
+                  + 3*acc -3*vel +pDef.init_pos;
                   variables_.push_back(var_t(jerk));
                   ++numConstants;
                   ++i;
@@ -156,15 +155,15 @@ problem_data<Point, Numeric, Safe> setup_control_points(const problem_definition
     {
         if(flag & END_VEL)
         {
-            point_t vel = pDef.end - (constraints.end_vel  / (num_t)degree) / pDef.totalTime;
+            point_t vel = pDef.end_pos - (pDef.end_vel  / (num_t)degree) / pDef.totalTime;
             if(flag & END_ACC)
             {
-                point_t acc = (constraints.end_acc  / (num_t)(degree * (degree-1)))
+                point_t acc = (pDef.end_acc  / (num_t)(degree * (degree-1)))
                         / (pDef.totalTime) * (pDef.totalTime)
-                        + 2* vel - pDef.end;
+                        + 2* vel - pDef.end_pos;
                 if(flag & END_JERK){
-                  point_t jerk = -constraints.end_jerk*pDef.totalTime*pDef.totalTime*pDef.totalTime/(num_t)(degree*(degree-1)*(degree-2))
-                  + 3*acc -3*vel + pDef.end;
+                  point_t jerk = -pDef.end_jerk*pDef.totalTime*pDef.totalTime*pDef.totalTime/(num_t)(degree*(degree-1)*(degree-2))
+                  + 3*acc -3*vel + pDef.end_pos;
                   variables_.push_back(var_t(jerk));
                   ++numConstants;
                   ++i;
@@ -191,7 +190,7 @@ problem_data<Point, Numeric, Safe> setup_control_points(const problem_definition
                 ++i;
             }
         }
-        variables_.push_back(var_t(pDef.end));
+        variables_.push_back(var_t(pDef.end_pos));
         ++numConstants; ++i;
     }
     // add remaining variables (only if no end_pos constraints)
diff --git a/include/curves/piecewise_curve.h b/include/curves/piecewise_curve.h
index 3e3f741c7bebf872c66b1108b2c714927f6b857a..7734a9c829e847d2d93de7cca151ed3d1a97a825 100644
--- a/include/curves/piecewise_curve.h
+++ b/include/curves/piecewise_curve.h
@@ -157,6 +157,25 @@ struct piecewise_curve : public curve_abc<Time, Numeric, Safe, Point> {
     return isContinuous;
   }
 
+  std::size_t num_curves() const
+  {
+      return curves_.size();
+  }
+
+  const curve_t& curve_at_time(const time_t t) const
+  {
+      return curves_[find_interval(t)];
+  }
+
+  const curve_t& curve_at_index(const std::size_t idx) const
+  {
+      if (Safe && idx >= num_curves())
+      {
+          throw std::length_error("curve_at_index: requested index greater than number of curves in piecewise_curve instance");
+      }
+      return curves_[idx];
+  }
+
   template <typename Bezier>
   piecewise_curve<Time, Numeric, Safe, Point, T_Point, Bezier> convert_piecewise_curve_to_bezier() {
     check_if_not_empty();
diff --git a/python/curves_python.cpp b/python/curves_python.cpp
index 817ab3fae8d2a97d1c6c39cf366e921596a4f8aa..3faaef1725b175ad60b87fca9c32fd8b7e52ae0f 100644
--- a/python/curves_python.cpp
+++ b/python/curves_python.cpp
@@ -154,18 +154,14 @@ namespace curves
   {
     return new piecewise_bezier_curve_t(bc);
   }
-  piecewise_bezier_curve_t* wrapPiecewiseBezierCurveEmptyConstructor()
+  piecewise_bezier_linear_curve_t*  wrapPiecewiseLinearBezierCurveConstructor(const bezier_linear_variable_t& bc)
   {
-    return new piecewise_bezier_curve_t();
+      return new piecewise_bezier_linear_curve_t(bc);
   }
   piecewise_cubic_hermite_curve_t* wrapPiecewiseCubicHermiteCurveConstructor(const cubic_hermite_spline_t& ch)
   {
     return new piecewise_cubic_hermite_curve_t(ch);
   }
-  piecewise_cubic_hermite_curve_t* wrapPiecewiseCubicHermiteCurveEmptyConstructor()
-  {
-    return new piecewise_cubic_hermite_curve_t();
-  }
   static piecewise_polynomial_curve_t discretPointToPolynomialC0(const pointX_list_t& points, const time_waypoints_t& time_points){
     t_pointX_t points_list = vectorFromEigenArray<pointX_list_t,t_pointX_t>(points);
     t_time_t time_points_list = vectorFromEigenVector<time_waypoints_t,t_time_t>(time_points);
@@ -296,13 +292,6 @@ namespace curves
       c.end_jerk = val;
   }
 
-  matrix_vector* bezier_linear_variable_t_operator_call(const bezier_linear_variable_t* b, const double t)
-  {
-      bezier_linear_variable_t::point_t p = b->operator ()(t);
-      matrix_vector* res = new matrix_vector(p.B(), p.c());
-      return res;
-  }
-
   bezier_t* bezier_linear_variable_t_evaluate(const bezier_linear_variable_t* b, const pointX_t& x)
   {
      return new bezier_t(evaluateLinear<bezier_t, bezier_linear_variable_t>(*b, x));
@@ -370,6 +359,7 @@ namespace curves
       .def("waypointAtIndex", &bezier_t::waypointAtIndex)
       .def_readonly("degree", &bezier_t::degree_)
       .def_readonly("nbWaypoints", &bezier_t::size_)
+      .def("split", &split_bezier, return_value_policy<manage_new_object>())
       .def("saveAsText", &bezier_t::saveAsText<bezier_t>,bp::args("filename"),"Saves *this inside a text file.")
       .def("loadFromText",&bezier_t::loadFromText<bezier_t>,bp::args("filename"),"Loads *this from a text file.")
       .def("saveAsXML",&bezier_t::saveAsXML<bezier_t>,bp::args("filename","tag_name"),"Saves *this inside a XML file.")
@@ -386,31 +376,44 @@ namespace curves
         .def_readonly("b", &matrix_pair::b)
         ;
 
-    class_<matrix_vector>
-        ("matrix_vector", no_init)
-        .def_readonly("A", &matrix_vector::A)
-        .def_readonly("b", &matrix_vector::b)
-        ;
-
     class_<LinearBezierVector>
     ("bezierVarVector", no_init)
       .def_readonly("size", &LinearBezierVector::size)
       .def("at", &LinearBezierVector::at, return_value_policy<manage_new_object>())
     ;
+
+    class_<linear_variable_t>
+    ("linear_variable", init<>())
+        .def(init<linear_variable_t::vector_x_t>())
+        .def(init<linear_variable_t::matrix_x_t>())
+        .def(init<linear_variable_t::matrix_x_t, linear_variable_t::vector_x_t>())
+        .def(init<linear_variable_t::matrix_x_t, linear_variable_t::vector_x_t>())
+        .def("__call__", &linear_variable_t::operator())
+        .def(self += linear_variable_t())
+        .def(self -= linear_variable_t())
+        .def(self *= double())
+        .def(self /= double())
+        .def("B", &linear_variable_t::B, return_value_policy<copy_const_reference>())
+        .def("c", &linear_variable_t::c, return_value_policy<copy_const_reference>())
+        .def("size", &linear_variable_t::size)
+        .def("isZero", &linear_variable_t::isZero)
+        .def("norm", &linear_variable_t::norm)
+        ;
+
     class_<bezier_linear_variable_t>
-    ("bezierVar", no_init)
+    ("bezier_linear_variable", no_init)
         .def("__init__", make_constructor(&wrapBezierLinearConstructor))
         .def("__init__", make_constructor(&wrapBezierLinearConstructorBounds))
         .def("min", &bezier_linear_variable_t::min)
         .def("max", &bezier_linear_variable_t::max)
-        //.def("__call__", &bezier_linear_control_t::operator())
-        .def("__call__", &bezier_linear_variable_t_operator_call, bp::return_value_policy<bp::manage_new_object>())
+        .def("__call__", &bezier_linear_variable_t::operator())
         .def("evaluate", &bezier_linear_variable_t_evaluate, bp::return_value_policy<bp::manage_new_object>())
         .def("derivate", &bezier_linear_variable_t::derivate)
         .def("compute_derivate", &bezier_linear_variable_t::compute_derivate)
         .def("compute_primitive", &bezier_linear_variable_t::compute_primitive)
         .def("split", &split_py, return_value_policy<manage_new_object>())
         .def("waypoints", &wayPointsToLists, return_value_policy<manage_new_object>())
+        .def("waypointAtIndex", &bezier_linear_variable_t::waypointAtIndex)
         .def_readonly("degree", &bezier_linear_variable_t::degree_)
         .def_readonly("nbWaypoints", &bezier_linear_variable_t::size_)
         ;
@@ -485,6 +488,9 @@ namespace curves
            "Add a new curve to piecewise curve, which should be defined in T_{min},T_{max}] "
            "where T_{min} is equal toT_{max} of the actual piecewise curve.")
       .def("is_continuous", &piecewise_polynomial_curve_t::is_continuous,"Check if the curve is continuous at the given order.")
+      .def("curve_at_index",&piecewise_polynomial_curve_t::curve_at_index, return_value_policy<copy_const_reference>())
+      .def("curve_at_time" ,&piecewise_polynomial_curve_t::curve_at_time , return_value_policy<copy_const_reference>())
+      .def("num_curves" ,&piecewise_polynomial_curve_t::num_curves)
       .def("saveAsText", &piecewise_polynomial_curve_t::saveAsText<piecewise_polynomial_curve_t>,bp::args("filename"),"Saves *this inside a text file.")
       .def("loadFromText",&piecewise_polynomial_curve_t::loadFromText<piecewise_polynomial_curve_t>,bp::args("filename"),"Loads *this from a text file.")
       .def("saveAsXML",&piecewise_polynomial_curve_t::saveAsXML<piecewise_polynomial_curve_t>,bp::args("filename","tag_name"),"Saves *this inside a XML file.")
@@ -499,6 +505,9 @@ namespace curves
       .def("compute_derivate",&piecewise_polynomial_curve_t::compute_derivate,"Return a piecewise_polynomial curve which is the derivate of this.",args("self","order"))
       .def("add_curve", &piecewise_bezier_curve_t::add_curve)
       .def("is_continuous", &piecewise_bezier_curve_t::is_continuous)
+      .def("curve_at_index",&piecewise_bezier_curve_t::curve_at_index, return_value_policy<copy_const_reference>())
+      .def("curve_at_time" ,&piecewise_bezier_curve_t::curve_at_time , return_value_policy<copy_const_reference>())
+      .def("num_curves" ,&piecewise_bezier_curve_t::num_curves)
       .def("saveAsText", &piecewise_bezier_curve_t::saveAsText<piecewise_bezier_curve_t>,bp::args("filename"),"Saves *this inside a text file.")
       .def("loadFromText",&piecewise_bezier_curve_t::loadFromText<piecewise_bezier_curve_t>,bp::args("filename"),"Loads *this from a text file.")
       .def("saveAsXML",&piecewise_bezier_curve_t::saveAsXML<piecewise_bezier_curve_t>,bp::args("filename","tag_name"),"Saves *this inside a XML file.")
@@ -511,7 +520,10 @@ namespace curves
     ("piecewise_cubic_hermite_curve", init<>())
       .def("__init__", make_constructor(&wrapPiecewiseCubicHermiteCurveConstructor))
       .def("add_curve", &piecewise_cubic_hermite_curve_t::add_curve)
-      .def("is_continuous", &piecewise_cubic_hermite_curve_t::is_continuous)
+      .def("is_continuous", &piecewise_cubic_hermite_curve_t::is_continuous,"Check if the curve is continuous at the given order.")
+      .def("curve_at_index",&piecewise_cubic_hermite_curve_t::curve_at_index, return_value_policy<copy_const_reference>())
+      .def("curve_at_time" ,&piecewise_cubic_hermite_curve_t::curve_at_time , return_value_policy<copy_const_reference>())
+      .def("num_curves" ,&piecewise_cubic_hermite_curve_t::num_curves)
       .def("saveAsText", &piecewise_cubic_hermite_curve_t::saveAsText<piecewise_cubic_hermite_curve_t>,bp::args("filename"),"Saves *this inside a text file.")
       .def("loadFromText",&piecewise_cubic_hermite_curve_t::loadFromText<piecewise_cubic_hermite_curve_t>,bp::args("filename"),"Loads *this from a text file.")
       .def("saveAsXML",&piecewise_cubic_hermite_curve_t::saveAsXML<piecewise_cubic_hermite_curve_t>,bp::args("filename","tag_name"),"Saves *this inside a XML file.")
@@ -520,6 +532,22 @@ namespace curves
       .def("loadFromBinary",&piecewise_cubic_hermite_curve_t::loadFromBinary<piecewise_cubic_hermite_curve_t>,bp::args("filename"),"Loads *this from a binary file.")
       ;
 
+    class_<piecewise_bezier_linear_curve_t, bases<curve_abc_t> >
+    ("piecewise_bezier_linear_curve_t", init<>())
+      .def("__init__", make_constructor(&wrapPiecewiseLinearBezierCurveConstructor))
+      .def("add_curve", &piecewise_bezier_linear_curve_t::add_curve)
+      .def("is_continuous", &piecewise_bezier_linear_curve_t::is_continuous,"Check if the curve is continuous at the given order.")
+      .def("curve_at_index",&piecewise_bezier_linear_curve_t::curve_at_index, return_value_policy<copy_const_reference>())
+      .def("curve_at_time" ,&piecewise_bezier_linear_curve_t::curve_at_time , return_value_policy<copy_const_reference>())
+      .def("num_curves" ,&piecewise_bezier_linear_curve_t::num_curves)
+      .def("saveAsText", &piecewise_bezier_linear_curve_t::saveAsText<piecewise_bezier_linear_curve_t>,bp::args("filename"),"Saves *this inside a text file.")
+      .def("loadFromText",&piecewise_bezier_linear_curve_t::loadFromText<piecewise_bezier_linear_curve_t>,bp::args("filename"),"Loads *this from a text file.")
+      .def("saveAsXML",&piecewise_bezier_linear_curve_t::saveAsXML<piecewise_bezier_linear_curve_t>,bp::args("filename","tag_name"),"Saves *this inside a XML file.")
+      .def("loadFromXML",&piecewise_bezier_linear_curve_t::loadFromXML<piecewise_bezier_linear_curve_t>,bp::args("filename","tag_name"),"Loads *this from a XML file.")
+      .def("saveAsBinary",&piecewise_bezier_linear_curve_t::saveAsBinary<piecewise_bezier_linear_curve_t>,bp::args("filename"),"Saves *this inside a binary file.")
+      .def("loadFromBinary",&piecewise_bezier_linear_curve_t::loadFromBinary<piecewise_bezier_linear_curve_t>,bp::args("filename"),"Loads *this from a binary file.")
+      ;
+
     /** END piecewise curve function **/
     /** BEGIN exact_cubic curve**/
     class_<exact_cubic_t, bases<curve_abc_t> >
diff --git a/python/optimization_python.cpp b/python/optimization_python.cpp
index cae1ec8225de9cc3cbe4fa65aade7e15b1bdee7f..d2a075e4c99a53753e53afc8c2c1772cafe989da 100644
--- a/python/optimization_python.cpp
+++ b/python/optimization_python.cpp
@@ -6,6 +6,7 @@
 
 #include <boost/python.hpp>
 #include <boost/python/enum.hpp>
+#include <boost/python/bases.hpp>
 
 namespace curves
 {
@@ -18,16 +19,6 @@ namespace optimization
     typedef problem_data<pointX_t, real>problem_data_t;
     typedef quadratic_problem<pointX_t, real> quadratic_problem_t;
 
-
-    void set_constraint(problem_definition_t &pDef, const curve_constraints_t& constraints)
-    {
-        pDef.curveConstraints = constraints;
-    }
-    curve_constraints_t get_constraint(problem_definition_t &pDef)
-    {
-        return pDef.curveConstraints;
-    }
-
     problem_data_t setup_control_points_t(problem_definition_t &pDef)
     {
         problem_data_t pData = setup_control_points<pointX_t,real, safe>(pDef);
@@ -78,11 +69,11 @@ namespace optimization
     }
     void set_start(problem_definition_t* pDef, const pointX_t &val )
     {
-        pDef->start = val;
+        pDef->init_pos = val;
     }
     void set_end(problem_definition_t* pDef, const pointX_t &val )
     {
-        pDef->end = val;
+        pDef->end_pos = val;
     }
     void set_degree(problem_definition_t* pDef, const std::size_t val )
     {
@@ -107,11 +98,11 @@ namespace optimization
     }
     Eigen::VectorXd get_start(const problem_definition_t* pDef)
     {
-        return pDef->start;
+        return pDef->init_pos;
     }
     Eigen::VectorXd get_end(const problem_definition_t* pDef)
     {
-        return pDef->end;
+        return pDef->end_pos;
     }
     std::size_t get_degree(const problem_definition_t* pDef)
     {
@@ -154,6 +145,12 @@ namespace optimization
         return new bezier_linear_variable_t(b.waypoints().begin(), b.waypoints().end(),b.min(), b.max(), b.mult_T_);
     }
 
+
+    problem_definition_t* wrapProblemDefinitionConstructor(const curve_constraints_t* c)
+    {
+      return new problem_definition_t(*c);
+    }
+
     void exposeOptimization()
     {
         // using the optimization scope
@@ -204,15 +201,15 @@ namespace optimization
             ;
 
 
-        bp::class_<problem_definition_t>
+        bp::class_<problem_definition_t, bp::bases<curve_constraints_t> >
             ("problem_definition", bp::init<int>())
+                .def("__init__", bp::make_constructor(&wrapProblemDefinitionConstructor))
                 .add_property("flag", &get_pd_flag, &set_pd_flag)
-                .add_property("start", &get_start, &set_start)
-                .add_property("end", &get_end, &set_end)
+                .add_property("init_pos", &get_start, &set_start)
+                .add_property("end_pos", &get_end, &set_end)
                 .add_property("degree", &get_degree, &set_degree)
                 .add_property("totalTime", &get_total_time, &set_total_time)
                 .add_property("splits", &get_split_times, &set_split_time)
-                .add_property("curveConstraints", &get_constraint, &set_constraint)
                 .def("inequality", &get_ineq_at, bp::return_value_policy<bp::manage_new_object>())
                 .def("removeInequality", &del_ineq_at)
                 .def("addInequality", &add_ineq_at)
diff --git a/python/python_variables.cpp b/python/python_variables.cpp
index 6f5d77a57e3c48e7841ef858ac86368db2e95d47..0c3323c0f50d271b76d3278abab3b1196e397d76 100644
--- a/python/python_variables.cpp
+++ b/python/python_variables.cpp
@@ -5,28 +5,28 @@
 
 namespace curves
 {
-  std::vector<linear_variable_3_t> matrix3DFromEigenArray(const point_list_t& matrices, const point_list_t& vectors)
+  std::vector<linear_variable_t> matrix3DFromEigenArray(const point_list_t& matrices, const point_list_t& vectors)
   {
     assert(vectors.cols() * 3  == matrices.cols() ) ;
-    std::vector<linear_variable_3_t> res;
+    std::vector<linear_variable_t> res;
     for(int i =0;i<vectors.cols();++i)
     {
-      res.push_back(linear_variable_3_t(matrices.block<3,3>(0,i*3), vectors.col(i)));
+      res.push_back(linear_variable_t(matrices.block<3,3>(0,i*3), vectors.col(i)));
     }
     return res;
   }
 
-  linear_variable_3_t fillWithZeros(const linear_variable_3_t& var, const std::size_t totalvar, const std::size_t i)
+  linear_variable_t fillWithZeros(const linear_variable_t& var, const std::size_t totalvar, const std::size_t i)
   {
-      linear_variable_3_t::matrix_x_t B(linear_variable_3_t::matrix_x_t::Zero(dim,totalvar*dim));
+      linear_variable_t::matrix_x_t B(linear_variable_t::matrix_x_t::Zero(dim,totalvar*dim));
       B.block(0,dim*i,dim,dim) = var.B();
-      return linear_variable_3_t (B,var.c());
+      return linear_variable_t (B,var.c());
   }
 
-  std::vector<linear_variable_3_t> computeLinearControlPoints(const point_list_t& matrices, const point_list_t& vectors)
+  std::vector<linear_variable_t> computeLinearControlPoints(const point_list_t& matrices, const point_list_t& vectors)
   {
-      std::vector<linear_variable_3_t> res;
-      std::vector<linear_variable_3_t> variables = matrix3DFromEigenArray(matrices, vectors);
+      std::vector<linear_variable_t> res;
+      std::vector<linear_variable_t> variables = matrix3DFromEigenArray(matrices, vectors);
       // now need to fill all this with zeros...
       std::size_t totalvar = variables.size();
       for (std::size_t i = 0; i < totalvar; ++i)
@@ -37,13 +37,13 @@ namespace curves
   /*linear variable control points*/
   bezier_linear_variable_t* wrapBezierLinearConstructor(const point_list_t& matrices, const point_list_t& vectors)
   {
-      std::vector<linear_variable_3_t> asVector = computeLinearControlPoints(matrices, vectors);
+      std::vector<linear_variable_t> asVector = computeLinearControlPoints(matrices, vectors);
       return new bezier_linear_variable_t(asVector.begin(), asVector.end()) ;
   }
 
   bezier_linear_variable_t* wrapBezierLinearConstructorBounds(const point_list_t& matrices, const point_list_t& vectors, const real T_min, const real T_max)
   {
-      std::vector<linear_variable_3_t> asVector = computeLinearControlPoints(matrices, vectors);
+      std::vector<linear_variable_t> asVector = computeLinearControlPoints(matrices, vectors);
       return new bezier_linear_variable_t(asVector.begin(), asVector.end(), T_min, T_max) ;
   }
 
@@ -64,7 +64,7 @@ namespace curves
   }
 
 
-  matrix_pair*
+  linear_variable_t*
           wayPointsToLists(const bezier_linear_variable_t& self)
   {
       typedef typename bezier_linear_variable_t::t_point_t t_point;
@@ -73,31 +73,45 @@ namespace curves
       // retrieve num variables.
       std::size_t dim = wps[0].B().cols();
       Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic> matrices (dim,wps.size() * 3);
-      Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic> vectors =
-              Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic>::Zero(3,wps.size());
+      Eigen::Matrix<real, Eigen::Dynamic, 1> vectors =
+              Eigen::Matrix<real, Eigen::Dynamic, 1>::Zero(3*wps.size());
       int i = 0;
       for(cit_point cit = wps.begin(); cit != wps.end(); ++cit, ++i)
       {
           matrices.block(0,i*3,dim,3) = cit->B().transpose();
-          vectors.block<3,1>(0,i)   =  cit->c();
+          vectors.segment<3>(i*3,i*3+2)   =  cit->c();
       }
-      matrix_pair* res (new matrix_pair(matrices, vectors));
-      //res->res = std::make_pair(matrices, vectors);
-      return res;
+      return new linear_variable_t(matrices.transpose(), vectors.transpose());
   }
 
+
   // does not include end time
-  LinearBezierVector* split_py(const bezier_linear_variable_t& self,  const vectorX_t& times)
+  piecewise_bezier_linear_curve_t* split_py(const bezier_linear_variable_t& self,  const vectorX_t& times)
   {
-      LinearBezierVector* res (new LinearBezierVector);
+      piecewise_bezier_linear_curve_t::t_curve_t curves;
       bezier_linear_variable_t current = self;
       for(int i = 0; i < times.rows(); ++i)
       {
           std::pair<bezier_linear_variable_t, bezier_linear_variable_t> pairsplit = current.split(times[i]);
-          res->beziers_.push_back(pairsplit.first);
+          curves.push_back(pairsplit.first);
           current = pairsplit.second;
       }
-      res->beziers_.push_back(current);
-      return res;
+      curves.push_back(current);
+      return new piecewise_bezier_linear_curve_t(curves);
+  }
+
+  // does not include end time
+  piecewise_bezier_curve_t* split_bezier(const bezier_t& self,  const vectorX_t& times)
+  {
+      piecewise_bezier_curve_t::t_curve_t curves;
+      bezier_t current = self;
+      for(int i = 0; i < times.rows(); ++i)
+      {
+          std::pair<bezier_t, bezier_t> pairsplit = current.split(times[i]);
+          curves.push_back(pairsplit.first);
+          current = pairsplit.second;
+      }
+      curves.push_back(current);
+      return new piecewise_bezier_curve_t(curves);
   }
 } // namespace curves
diff --git a/python/python_variables.h b/python/python_variables.h
index fdcb62fcb5da8a6e818b121cf8423bdbf26001c1..488e1527d00ae7efa39c26690cba7898341312c8 100644
--- a/python/python_variables.h
+++ b/python/python_variables.h
@@ -22,9 +22,9 @@
 namespace curves
 {
   static const int dim = 3;
-  typedef linear_variable<real> linear_variable_3_t;
+  typedef linear_variable<real, true> linear_variable_t;
   typedef quadratic_variable<real> quadratic_variable_t;
-  typedef bezier_curve  <real, real, true, linear_variable_3_t> bezier_linear_variable_t;
+  typedef bezier_curve  <real, real, true, linear_variable_t> bezier_linear_variable_t;
 
   /*linear variable control points*/
   bezier_linear_variable_t* wrapBezierLinearConstructor(const point_list_t& matrices, const point_list_t& vectors);
@@ -44,23 +44,11 @@ namespace curves
       matrix_x_t b() {return b_;}
   };
 
-  struct matrix_vector
-  {
-      matrix_vector() {}
-      matrix_vector(const Eigen::Ref<const matrix_x_t > A, const Eigen::Ref<const Eigen::VectorXd > b)
-          : A_(A), b_(b){}
-      matrix_x_t A_;
-      Eigen::VectorXd b_;
-      matrix_x_t A() {return A_;}
-      Eigen::VectorXd b() {return b_;}
-  };
-
-
   Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic> cost_t_quad(const quadratic_variable_t& p);
   Eigen::Matrix<real, Eigen::Dynamic, 1> cost_t_linear(const quadratic_variable_t & p);
   real cost_t_constant(const quadratic_variable_t & p);
 
-  matrix_pair* wayPointsToLists(const bezier_linear_variable_t& self);
+  linear_variable_t *wayPointsToLists(const bezier_linear_variable_t& self);
 
   struct LinearBezierVector
   {
@@ -73,8 +61,16 @@ namespace curves
     }
   };
 
-  // does not include end time
-  LinearBezierVector* split_py(const bezier_linear_variable_t& self,  const vectorX_t& times);
+  struct BezierVector
+  {
+    std::vector<bezier_linear_variable_t> beziers_;
+    std::size_t size() {return beziers_.size();}
+    bezier_linear_variable_t* at(std::size_t i)
+    {
+      assert (i<size());
+      return new bezier_linear_variable_t(beziers_[i]);
+    }
+  };
 
 
   /*** TEMPLATE SPECIALIZATION FOR PYTHON ****/
@@ -103,13 +99,17 @@ namespace curves
   typedef curves::piecewise_curve <real, real, true, pointX_t, t_pointX_t, polynomial_t> piecewise_polynomial_curve_t;
   typedef curves::piecewise_curve <real, real, true, pointX_t, t_pointX_t, bezier_t> piecewise_bezier_curve_t;
   typedef curves::piecewise_curve <real, real, true, pointX_t, t_pointX_t, cubic_hermite_spline_t> piecewise_cubic_hermite_curve_t;
+  typedef curves::piecewise_curve <real, real, true, linear_variable_t, std::vector<linear_variable_t>, bezier_linear_variable_t> piecewise_bezier_linear_curve_t;
   typedef curves::exact_cubic  <real, real, true, pointX_t, t_pointX_t> exact_cubic_t;
 
   // Bezier 3
   typedef curves::bezier_curve  <real, real, true, Eigen::Vector3d> bezier3_t;
-
   typedef curves::Bern<double> bernstein_t;
 
+  // does not include end time
+  piecewise_bezier_linear_curve_t* split_py(const bezier_linear_variable_t& self,  const vectorX_t& times);
+  piecewise_bezier_curve_t* split_bezier(const bezier_t& self,  const vectorX_t& times);
+
   /*** TEMPLATE SPECIALIZATION FOR PYTHON ****/
 } //namespace curve.
 
@@ -123,12 +123,13 @@ EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::curve_constraints_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::piecewise_polynomial_curve_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::piecewise_bezier_curve_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::piecewise_cubic_hermite_curve_t)
+EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::piecewise_bezier_linear_curve_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::exact_cubic_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::matrix_x_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::pointX_t)
-EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::linear_variable_3_t)
+EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::linear_variable_t)
+EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::bezier_linear_variable_t)
 EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::matrix_pair)
-EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(curves::matrix_vector)
 
 
 #endif //_VARIABLES_PYTHON_BINDINGS
diff --git a/python/test/optimization.py b/python/test/optimization.py
index 52df7b30954261f01c92c916c57aaa82383a7c27..05c11e9be16d30c682ad75520d4a913ab7bc550c 100644
--- a/python/test/optimization.py
+++ b/python/test/optimization.py
@@ -18,17 +18,14 @@ class TestProblemDefinition(unittest.TestCase):
 
      #generate problem data
      def test_problem_definition(self):
-          c = curve_constraints(3)
-          c.init_vel = matrix([0., 1., 1.]).transpose()
-          c.end_vel = matrix([0., 1., 1.]).transpose()
-          c.init_acc = matrix([0., 1., -1.]).transpose()
-          c.end_acc = matrix([0., 0., 0]).transpose()
-
           pD = problem_definition(3)
-          pD.start
-          pD.curveConstraints = c
-          pD.start = array([[0.,0.,0.]]).T
-          pD.end = array([[1.,1.,1.]]).T
+          pD.init_pos
+          pD.init_vel = matrix([0., 1., 1.]).transpose()
+          pD.end_vel = matrix([0., 1., 1.]).transpose()
+          pD.init_acc = matrix([0., 1., -1.]).transpose()
+          pD.end_acc = matrix([0., 0., 0]).transpose()
+          pD.init_pos = array([[0.,0.,0.]]).T
+          pD.end_pos = array([[1.,1.,1.]]).T
           pD.flag = constraint_flag.INIT_VEL | constraint_flag.INIT_POS
 
           quadratic_problem = generate_integral_problem(pD,integral_cost_flag.ACCELERATION)
@@ -38,8 +35,8 @@ class TestProblemDefinition(unittest.TestCase):
           bezierLinear = problem.bezier()
           bezierFixed = bezierLinear.evaluate(array([zeros(12)]).T)
           self.assertTrue(bezierFixed.nbWaypoints == pD.degree + 1)
-          self.assertTrue(norm(bezierFixed(0.) - pD.start) <= 0.001)
-          self.assertTrue(norm(bezierFixed.derivate(0.0, 1) - c.init_vel) <= 0.001)
+          self.assertTrue(norm(bezierFixed(0.) - pD.init_pos) <= 0.001)
+          self.assertTrue(norm(bezierFixed.derivate(0.0, 1) - pD.init_vel) <= 0.001)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/python/test/sandbox/fit.py b/python/test/sandbox/fit.py
index f75cc81216cfe4fc49c3c84bf0161d34e9274058..3eae4fb365bee29e5c7903ec7da4e019670cf534 100644
--- a/python/test/sandbox/fit.py
+++ b/python/test/sandbox/fit.py
@@ -18,25 +18,27 @@ from qp import to_least_square, quadprog_solve_qp
 #points given as pairs (pt, t)
 #does not try to fit anything
 def default_fit(degree, ptsTime, dim = 3, totalTime =1., constraintFlag = constraint_flag.NONE, curveConstraints = None):
-    pD = problem_definition(dim)
+    pD = None
+    if curveConstraints is None:
+        pD = problem_definition(dim)        
+    else:
+        pD = problem_definition(curveConstraints)       
     #set initial and goal positions to the ones of the list (might not be used if constraints do not correspond)
-    pD.start = array([ptsTime[0][0]]).T
-    pD.end   = array([ptsTime[-1][0]]).T
+    pD.init_pos = array([ptsTime[0][0]]).T
+    pD.end_pos   = array([ptsTime[-1][0]]).T
     #assign curve constraints
     pD.totalTime = totalTime
     pD.degree = degree
     pD.flag = constraintFlag
     problem = setup_control_points(pD)
     bezierLinear = problem.bezier()
-    if curveConstraints is not None:
-        pD.curveConstraints = curveConstraints
     pD.totalTime = totalTime
     pD.degree = degree
     problem = setup_control_points(pD)
     bezierLinear = problem.bezier()
 
     allsEvals = [(bezierLinear(time), pt) for (pt,time) in ptsTime]
-    allLeastSquares = [to_least_square(el.A, el.b + pt) for (el, pt) in  allsEvals]
+    allLeastSquares = [to_least_square(el.B(), el.c() + pt) for (el, pt) in  allsEvals]
     Ab = [sum(x) for x in zip(*allLeastSquares)]
     
     res = quadprog_solve_qp(Ab[0] + identity(problem.numVariables * dim) * 0.0001, Ab[1])
@@ -77,7 +79,7 @@ if __name__ == '__main__':
     plot_fit_and_original(ax)
             
     
-    bFit = default_fit(degree-1, ptsTime, dim = dim, constraintFlag = constraint_flag.INIT_VEL | constraint_flag.INIT_POS, curveConstraints = c)    
+    bFit = default_fit(degree-1, ptsTime, dim = dim, constraintFlag = constraint_flag.END_POS | constraint_flag.INIT_POS, curveConstraints = c)    
     ax = fig.add_subplot(223, projection="3d")    
     plot_fit_and_original(ax)
     
diff --git a/python/test/sandbox/plot_bezier.py b/python/test/sandbox/plot_bezier.py
index b88dcc1ccd2c5bacfb40a4b68814b8da82a53167..f8f4ea0624fae0864fbeea90379f4d17dad09f0e 100644
--- a/python/test/sandbox/plot_bezier.py
+++ b/python/test/sandbox/plot_bezier.py
@@ -13,7 +13,7 @@ def plotControlPoints2D(bez, axes = [0,1], color = "r", ax = None):
         plt.scatter(x, y, color = color)
         
 def plotBezier2D(bez, axes = [0,1], step = 100., color = "b", showControlPoints = False, ax = None):
-    points1 = np.array([(bez(i / step * bez.max())[axes[0]], bez(i / step * bez.max())[axes[1]]) for i in range(int(step)+1)])
+    points1 = np.array([(bez(i / step * (bez.max() - bez.min()) + bez.min())[axes[0]], bez(i / step * (bez.max() - bez.min()) + bez.min())[axes[1]]) for i in range(int(step)+1)])
     x = points1[:, 0]
     y = points1[:, 1]
     if ax is None:        
@@ -37,7 +37,7 @@ def plotControlPoints(bez,color = "r", ax = None):
     ax.scatter (x, y, z, color = color)
         
 def plotBezier(bez, step = 100., color = "b", linewidth = 2., showControlPoints = False, ax = None):
-    points1 = np.array([(bez(i / step * bez.max())[0], bez(i / step * bez.max())[1], bez(i / step * bez.max())[2]) for i in range(int(step)+1)])
+    points1 = np.array([(bez(i / step * (bez.max() - bez.min()) + bez.min())[0], bez(i / step * (bez.max() - bez.min()) + bez.min())[1], bez(i / step * (bez.max() - bez.min()) + bez.min())[2]) for i in range(int(step)+1)])
     x = points1[:, 0]
     y = points1[:, 1]
     z = points1[:, 2]
diff --git a/python/test/sandbox/test.ipynb b/python/test/sandbox/test.ipynb
index c5eb5264848fbcb9926c306c02c0f798d7ad784e..d83970b7e4203a01d471b5723d90b47ded503564 100644
--- a/python/test/sandbox/test.ipynb
+++ b/python/test/sandbox/test.ipynb
@@ -30,19 +30,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -71,7 +68,7 @@
     "ref = bezier(waypoints)\n",
     "\n",
     "#plotting the curve with its control points\n",
-    "plotBezier(ref,showControlPoints = True)\n",
+    "plotBezier(ref,showControlPoints = True, color=\"g\")\n",
     "plt.show()"
    ]
   },
@@ -163,21 +160,21 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "A: \n",
+      "B: \n",
       "[[1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0]\n",
       " [0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0]\n",
       " [0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0]]\n",
-      "b:\n",
+      "c:\n",
       "[0.0 0.0 0.0]\n",
-      "Shape of A:  (3, 12)\n"
+      "Shape of B:  (3, 12)\n"
      ]
     }
    ],
    "source": [
     "linearVariable = variableBezier(0.)\n",
-    "print \"A: \\n\", linearVariable.A\n",
-    "print \"b:\\n\",linearVariable.b\n",
-    "print \"Shape of A: \", linearVariable.A.shape"
+    "print \"B: \\n\", linearVariable.B()\n",
+    "print \"c:\\n\",linearVariable.c()\n",
+    "print \"Shape of B: \", linearVariable.B().shape"
    ]
   },
   {
@@ -199,7 +196,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "A: \n",
+      "B: \n",
       "[[0.5 0.0 0.0 0.4 0.0 0.0 0.1 0.0 0.0 0.0 0.0 0.0]\n",
       " [0.0 0.5 0.0 0.0 0.4 0.0 0.0 0.1 0.0 0.0 0.0 0.0]\n",
       " [0.0 0.0 0.5 0.0 0.0 0.4 0.0 0.0 0.1 0.0 0.0 0.0]]\n"
@@ -207,7 +204,7 @@
     }
    ],
    "source": [
-    "print \"A: \\n\", variableBezier(0.2).A"
+    "print \"B: \\n\", variableBezier(0.2).B()"
    ]
   },
   {
@@ -228,13 +225,15 @@
     "def to_least_square(A, b):\n",
     "    return dot(A.T, A), - dot(A.T, b)\n",
     "\n",
-    "#first evaluate variableBezier for each time sampled\n",
-    "allsEvals = [(variableBezier(time), pt) for (pt,time) in ptsTime]\n",
-    "#then compute the least square form of the cost for each points\n",
-    "allLeastSquares = [to_least_square(el.A, el.b + pt) for (el, pt) in  allsEvals]\n",
-    "#and finally sum the costs\n",
-    "Ab = [sum(x) for x in zip(*allLeastSquares)]\n",
-    "A = Ab[0]; b = Ab[1]"
+    "def genCost(variableBezier, ptsTime):\n",
+    "    #first evaluate variableBezier for each time sampled\n",
+    "    allsEvals = [(variableBezier(time), pt) for (pt,time) in ptsTime]\n",
+    "    #then compute the least square form of the cost for each points\n",
+    "    allLeastSquares = [to_least_square(el.B(), el.c() + pt) for (el, pt) in  allsEvals]\n",
+    "    #and finally sum the costs\n",
+    "    Ab = [sum(x) for x in zip(*allLeastSquares)]\n",
+    "    return Ab[0], Ab[1]\n",
+    "A, b = genCost(variableBezier, ptsTime)"
    ]
   },
   {
@@ -282,31 +281,414 @@
     }
    ],
    "source": [
-    "fitBezier = variableBezier.evaluate(res.reshape((-1,1)) ) \n",
+    "def evalAndPlot(variableBezier, res):\n",
+    "    fitBezier = variableBezier.evaluate(res.reshape((-1,1)) ) \n",
+    "    #plot reference curve in blue, fitted curve in green\n",
+    "    fig = plt.figure()\n",
+    "    ax = fig.add_subplot(111, projection=\"3d\")  \n",
+    "    plotBezier(ref, ax = ax, linewidth=4.) #thicker line to visualize overlap\n",
+    "    plotBezier(fitBezier, ax = ax, color =\"g\", linewidth=3.) \n",
+    "    plt.show()\n",
+    "    return fitBezier\n",
+    "    \n",
+    "fitBezier = evalAndPlot(variableBezier, res)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### initial and terminal constraints\n",
+    "Let's try to fit the reference curve with a curve of lesser degree"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pD.degree = refDegree - 1\n",
+    "\n",
+    "\n",
+    "problem = setup_control_points(pD)\n",
+    "variableBezier = problem.bezier()\n",
+    "\n",
+    "A, b = genCost(variableBezier, ptsTime)\n",
+    "res = quadprog_solve_qp(A, b)\n",
+    "fitBezier = evalAndPlot(variableBezier, res)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that the initial and goal positions are not reached. \n",
+    "A constraint_flag can be used to impose constraints on the initial/goal positions\n",
+    "and derivatives if required.\n",
+    "Let's rewrite simplefit to handle such case"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from curves.optimization import constraint_flag\n",
+    "\n",
+    "pD.flag = constraint_flag.INIT_POS | constraint_flag.END_POS\n",
+    "#set initial position\n",
+    "pD.init_pos = array([ptsTime[ 0][0]]).T\n",
+    "#set end position\n",
+    "pD.end_pos   = array([ptsTime[-1][0]]).T\n",
+    "problem = setup_control_points(pD)\n",
+    "variableBezier = problem.bezier()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By imposing the initial and final position, we effectively reduce the number of variables by 6:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of B:  (3, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print \"Shape of B: \", variableBezier(0).B().shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The least squares problem then has the following solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "prob = setup_control_points(pD)\n",
+    "variableBezier = prob.bezier()\n",
+    "A, b = genCost(variableBezier, ptsTime)\n",
+    "res = quadprog_solve_qp(A, b)\n",
+    "_ = evalAndPlot(variableBezier, res)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To impose constraints on the derivatives, we can activate the appropriate constraint flags as follows.\n",
+    "Note that derivatives constraints on velocities will only be considered if the constraints on position are also active.\n",
+    "For instance to impose a 0 initial velocity we can proceed as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#values are 0 by default, so if the constraint is zero this can be skipped\n",
+    "pD.init_vel = array([[0., 0., 0.]]).T\n",
+    "pD.init_acc = array([[0., 0., 0.]]).T\n",
+    "pD.end_vel = array([[0., 0., 0.]]).T\n",
+    "pD.end_acc = array([[0., 0., 0.]]).T\n",
+    "pD.flag = constraint_flag.END_POS | constraint_flag.INIT_POS | constraint_flag.INIT_VEL  | constraint_flag.END_VEL  | constraint_flag.INIT_ACC  | constraint_flag.END_ACC"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "However, the definition of the variable problem will result in an error. Do you know why ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "In setup_control_points; too many constraints for the considered degree\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    prob = setup_control_points(pD)\n",
+    "except RuntimeError,e:\n",
+    "    print e"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Indeed, there are not enough variables left in the problem to satisfy the constraints. We need to increase the degree of the curve:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pD.degree = refDegree + 4\n",
+    "prob = setup_control_points(pD)\n",
+    "variableBezier = prob.bezier()\n",
+    "A, b = genCost(variableBezier, ptsTime)\n",
+    "res = quadprog_solve_qp(A, b)\n",
+    "fitBezier = evalAndPlot(variableBezier, res)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can check that the derivatives of the curve are 0 at start and end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "initial velocity [0.0 0.0 0.0]\n",
+      "initial acceleration [0.0 0.0 0.0]\n",
+      "end velocity [0.0 0.0 0.0]\n",
+      "end acceleration [0.0 0.0 0.0]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print \"initial velocity\", fitBezier.derivate(fitBezier.min(),1)\n",
+    "print \"initial acceleration\", fitBezier.derivate(fitBezier.min(),1)\n",
+    "print \"end velocity\", fitBezier.derivate(fitBezier.max(),1)\n",
+    "print \"end acceleration\", fitBezier.derivate(fitBezier.max(),1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Of course, with such constraints the curve does not really look like the original one anymore.\n",
+    "Although it is not recommended, the library is robust enough to allow for adding an arbitrary number of control points.\n",
+    "Just for fun, let's add 60 more control points and check that the curve is matched better"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pD.degree = refDegree + 60\n",
+    "prob = setup_control_points(pD)\n",
+    "variableBezier = prob.bezier()\n",
+    "A, b = genCost(variableBezier, ptsTime)\n",
+    "#regularization matrix \n",
+    "reg = identity(A.shape[1]) * 0.001\n",
+    "res = quadprog_solve_qp(A + reg, b)\n",
+    "fitBezier = evalAndPlot(variableBezier, res)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Adding equality and inequality constraints\n",
+    "\n",
+    "Suppose we want to add specific constraint.\n",
+    "For instance, we want that the velocity be exactly 0 at t = 0.8, additionally to the start and goal positions being satisfied. This can be done easily by obtaining the variable equation for the variable curve at that time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAADuCAYAAAAOR30qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXl8G/WdPv7osiTb8hkfic/EVxzncg5CWtrS7cKyvVgoLW2hLdey3S4tLT0IZwkQQihQAt0etAVS+muhwC60gWW/S5YbQi5ykMOxJN+3Zcm6NdJofn94P8OMNCPNjGYc28zzevkFkTSfGY1mnnl/3p/n/bwNDMNAhw4dOnSceRjP9AHo0KFDh44Z6ISsQ4cOHXMEOiHr0KFDxxyBTsg6dOjQMUegE7IOHTp0zBHohKxDhw4dcwQ6IevQoUPHHIFOyDp06NAxR6ATsg4dOnTMEZhlfl4v69OhQ4cO+TBI+ZAeIevQoUPHHIFOyDp06NAxR6ATsg4dOnTMEeiErEOHDh1zBDoh69ChQ8ccgU7IOnTo0DFHoBOyDh06dMwR6ISsQ4cOHXMEOiHr0KFDxxyBTsg6dOjQMUegE7IOHTp0zBHohKxDhw4dcwRyzYV06MgIhmFA0zQAwGQywWCQ5KmiQ4cO6ISsQyUkk0nQNI1EIoFYLMa+bjAYYDKZ2D+j0Qij0QiDwaCTtQ4dKdAJWUdOSCaTSCQSbFRsMBhYwmWYGbdWQtRckM+ZTCaYzWadqHXoAGAgN41E6H7IOsAwDBiGQTweRzKZBACWSBmGAUVRWUmVjJF6/elErWOBQtLFqxOyDslgGIaNiFOJmPsZKYScaR9CRA3M5KQpikJhYSGb/tCJWsc8gaSLVE9Z6MgKLhEfPXoUK1as0GzBToxgyTEcPnwY69at432Gm59OzVPr0DGfoBOyDlEQxUQikQDDMDAYDIhGo+z/zyYIURsMBpjNH162hKhpmk47LkLQQguKOnTMReiErCMNQkRsNM5I1rmLdXMBmSJqkudOTaHoRK1jrkInZB0sGIZhFROpRExgNBrZ/LEY5gKxZSJqAEgkEojH4+zrXq8XBQUFKCgo0IlaxxmDTsg6WCIm0jQhIiaYaxGyXBByTSVZr9cLo9EIq9XKI2ry2VTVh170okML6IT8EQa3mAMQjyq5kBIhz1cIPYhStdRk5sAwTMbUh07WOpRAJ+SPIIhioqurC8uWLZMV7UmJkM/Eol+uEDtmsYhaStGL2WzWiVqHLOiE/BGBUDGH1+sFIC/nO99TFmohG1Enk0m2hLyrqwttbW160YuOrNAJeYEjUzGHkvSD1G3mY5SsxvEKEXUoFILJZOJJ9CiK4m3HTX3oRS8fXeiEvECRSsRcHS+BEkKWEiGHQiFYLBZYrVZFx34mMBtRf7aiFyEttVCOWld+LFzohLzAIKQhFiMCNSNkhmEwMTEBt9sNs9kMmqYRj8dhNptZORn5y8vLU/z9FiKUELWupV6Y0Al5gSBTMYcY1IiQGYbB2NgYenp6UFRUhNWrV8NsNrPHEI/HEQqFEAqFMDExgZ6eHiQSCZjNZhQWFvKI2mKxKPruamAuplikFL3s3bsX69evZ9/TiXp+QyfkeQ5i5jMxMYHy8nJJREyglJCTySSSySRGR0fR29uL0tJSdHZ2wmazAQAvP2qxWFBSUoKSkhLeOBRFsUQ9NjaGUCiERCIBi8WSFlGfSaKei0glapPJBEC86AXQiXq+QCfkeQpuMQdN03C5XKioqJA1htFolJ07NRgMmJiYwOnTp7Fo0SKsX79eUa44Ly8PeXl5KC0t5b2ejagpisL09DQKCgp4nhY6sis/xIhaTKKnY/ahX9HzDELFHGazWVGxBol2pYCmaQwODmJwcBBlZWXYuHGjJrngbEQ9MTGB0dFRlqjz8vLSImolRD0XUxZqQaqWOrXoJR6Pw2q1wmq16hK9WYJOyPMEQp05cr0xpKQsEokEBgYGMDQ0hMWLF6Ourg6FhYWzvjBHiDovLw9tbW0APkzXkIh6ZGQEoVAINE2rRtRqYK7qtrMRdU9PD6qqqlBUVMTbRi960Q46Ic9hZOrMoQYyEXI8Hkd/fz9GRkZQW1uLs88+G2azGT09PXOGYAwGAxvBlZWVsa9LJerCwkLk5+ezi5DzDVodM7m+kskkLBZLWo6aW/TC3UYveskdOiHPQUjpzKEGhAiZoij09fVhfHwcdXV12Lx5M3tDim2TijNdzZeNqIPBIMLhMIaGhhAOh1mJHgCUlpbyXN9yhZapEJJa0ArJZJI3vlhETY5FL3rJHTohzyFIKeZQE1xyjcVi6O3txeTkJBoaGrB582bBm/1Mk20u4BJ1eXk5+zrDMPjggw9QVFSEeDyOoaEhhEIhJJNJWK3WtNSHHKLWkpBTCVNt0DQt+btK0VJzXzMYDJienkZFRYVe9MKBTshzAFwN8YkTJ1BbW4uioiLNL0yj0YhoNIoTJ07A5/OhsbERLS0tGW9yo9HIu7kWAsh0m0THBAzDIBaLsakPLlHbbDYeSefn5wuS13wn5FzHFyNqogwqLi7Wi1440An5DEKsqo5Ex0rGk7pdOBzG6OgoYrEY2tra0N7eLmnb+Rwhy4XBYIDNZoPNZkuLqKPRKEvUU1NTCIfDgkRttVrnLSEnk0lV0jZiY5OFQS4+6p1edEI+A8jUmcNkMimKQImmONvFGQwG4Xa7EYlEUFxcDLvdjurqasn7+SgRshgMBgPsdjvsdjsWLVrEvi5E1KFQCOFwGEePHk1bTMyVTJU+uOfC+KRaMxWZUh9ku4Vc9KIT8ixCSmcOk8mkSFNM8sFiN3kgEIDL5QJFUWhqakJZWRlGRkbSFmCk7mehQY3UghBRUxSFEydOoKWlBaFQCMFgEB6PB+FwGAzDwG63p6U+pBK11ot6Wq5fyMlPk2Ph/pcgG1Hv3LkTW7ZsmTfVnjohzwLkdObIJUKmaTot6pienobL5UIymURTUxOv4EJOYQh3m496hCwHhDTFIupIJMJG1JOTk7KIWuuUhZaQS8hiyEbUzz33HG655Zac9zNb0AlZQygp5lC6aJYaWXu9XrhcLhiNRjQ1NaG4uFhwX2r7IZMHAACeeZDdbp/TU0itHjKZpv0GgwH5+fnIz8/nlb1LIerCwkLNUxZaQgohJ5IJBKkgSmwlGT8nBG7gMJ/OkU7IKoMsSng8HhiNRuTn58ua+uUSIScSCUxOTsLtdrMVbQ6HI+M2akXI09PTcDqdMBgMaGhogMFgQDgcRiAQwOjoKKLRKEtAhKhJxd9cuWG0OA4lqRAxok4mk2yOOhgMwuv1IhQKIRAIpEXUdrt9TkfPYjlkABgPjWP171cjnAjDbDTj8c8+jgtbL1S8r7lyfUmBTsgqIVVDPDk5CavVisLCQlnjmEwm2XldIs86evQoHA4HVqxYIWm/ubi9Efh8PrhcLhgMBjQ3N6O4uJidFRQWFqKyspL9LE3TCIfDCIVC8Hq9GBwcRCwWg8lkYgl6oXkmqyl7Iw94QtRFRUXwer1YtmwZL6IeHx9HJBIBAMVErfU6gVCEHKSCOPdP5+L01Gn2tUQygdcHXldEyIlEQjOViFbQCTlHiBVzKDX8kRMhc72IaZpGc3OzLMWE0pQFwzDw+XxwOp0wGo1oaWnh+R2IwWQyweFwpEXtiUSC55nc29uLeDzOOrxxiVoraKUXno1KPaPRKHh+ksmkKFHn5+enETX3OLWUvAF8Qo7TcVz6wqV4pfcVwc/ecNYNivYxPT0tmKqby9AJWSGydeYwm81p9f5SIIUkhbyIe3t7Za8kKyHkYDCI8fFxxGIxtLa2ihKxHCIym80oLi5Ou3m4fhSjo6MIBoMIhUI4cuQIj6jFijLmAs5kYUgmog6Hw2kpJeBDorZarWz6TYvjTyQSsNvt+P4r38djRx8T/MzGxRvx4pdfhM1sU7QPv9+f5sM916ETskxI7cyhNBecabtkMonh4WH09fWleRFr2bAUmFkkdDqdAICioiJ0dnbK2pcSCFlx7tu3D8uXL2fJmVuUwV3wUpJHnW8RslKVhdFoRGFhYVpKiRB1KBSCz+dDJBLB/v372Zw299zabLacvtejJx/FL07+QvC9xQWLsfdbe1FqKxV8Xyp8Pp8eIS9UZCrmEIKahEzTNIaGhjAwMIDKykpBL2Il+mUpsrepqSm4XC5YLBYsX74cwIwt45lCJj+KbNPzTGSilcpiLhKyGLhEXVhYiEQigY6ODh5R+/1+jIyMIBKJsDltbuojG1H/6cSf8O2Xvy36/ol/PoFaR60q30dPWSxASCnmEIIahEy8iIeHh1FdXY2zzjpLNC2hRC6XqWNIKhGTvC/xcphryKRMiEQiCAaDaWTCJZJkMqkJKWtNyLNRuMEl6tTPEKKenp7G8PAwotGoIFG/PfY2Lv6Pi0X39+433kVHRYeq32F6elpPWSwUkGIOl8uFyspKVr4mFWazmSVxOTCZTIjH43C5XBgZGUFNTQ02bdqU1VxdrZSFx+OBy+WC1WpFe3t72k043wpDxPKohEyIfCwYDOLIkSNpzVcLCwtzqvLSelFPq9y5FJ2w2CItl6j39u3F11//uugYuy/ZjU/Wf1KVY06FTsgLAKnFHOFwGPF4XPZNpSRCpigKvb298Pl8qKqqSvMizrY/pYTMMAwbEVut1oyyOal+yHMdqWQSDAaxYsUKGI1GVuebqvjg6qeJsX02aBnFalmpl8vYJpMJnqQHq/+0WvQzNzXfhAvqLkB8NI4D4wfSLE7VMGXy+Xyoq6vLaYzZhk7IyNyZI5dIVyohEy9ij8eD2tpaFBYWor6+Xtb+SA80OTAYDIjFYti/fz9sNpsk/fJ8i5DlIpviIxgMYnh4mO1AQrTmXDLhEpmWfhNaErJS601PxIPOxzrhi/kE37/nU/fguvXX4eDBg1i9ejV7n5Dcf6o+nZv6kFtIpKss5hmkdOZQSshmszkrIUejUfT09MDr9bJexAaDAYODg7L3JydlQSoJXS4XYrEYOjs7JWt85wIha5EGyDamkOKD65ccDAbTFB+FhYWgaRo0TWtCnlpHyHLSIeF4GOc9dR6OTRwTfP/bnd/GjnN38NpDcR0Oi4qK0iSUiUQiYyER90+IqP1+v76oNx9ApGvkRsnUmSNXsx8hhMNhuN1uBAIBLF26FMuXL8+ZYKSkLBiGYUur8/Pz0dHRwdpCSsVCdXtTgkx+yUTxMTY2hlAohIMHDwIAr3Q8V/nYbC3qZUIimcDlf7scL7leEnz/C81fwB8+/weYjOljZTt2s9mckaiJc15/fz8oimKJOj8/H0eOHMHU1JROyHMZ2Yo5hKA0QhYak+tFvHTpUnR0dKhaViv2AEgl4lWrViE/P1/RfuZChKwF1PxOXMVHMpmEw+FAQ0MDTz6WqkoQKh3Pdm1onQ7JlCNnGAY/efUn+M3h3wi+v7ZyLV6+9GXkW5RdZ5mQiaiJNv2ll17CwYMHcdlll2HRokX45Cc/ibvvvlvWfq666irs3r0blZWV+OCDDwAAP/7xj/G3v/0NeXl5aGpqwuOPP65qWuQjQchSizmEoLTijgshL2K1IxuhyJVhGExMTMDtdqOwsDAnIs60n9R9jo+PIxQKweFw5KxSENuHFpGh1oUhXPlYVVUV+xluDpUb8ZnN5jSi5p5LrXPIpOgoFQ8feBi3vnGr4HultlIcuvIQyu3lgu9rCW7+/1e/+hUuuOAC/Nd//RcYhsHw8LDs8a644gpcd911+OY3v8m+dt5552H79u0wm8248cYbsX37duzYsUO976DaSHMQREMcDofhdDrR0dEh+wI2mUyKImRg5qI+dOgQkskkli1bxuuArDa4KYtUIl69enXOREwgRlpkny6XCw6HA/n5+ZiYmEBPTw8SiQTy8vJYciEqBSWSrfmg4OBCysNDLIcaj8d5hS7BYJB3Lkn3bLU6ZHMhRPbPnHoGV790teg2x64+hobiBkljz8bvGAqF2HOjJHXxyU9+Er29vbzXzj//fPb/zz77bDz77LO5HiYPC5KQU4s5TCYTQqGQootAyuJcKogXcSwWw6pVqxRNaeRGgcR+c3x8HG63Gw6HA2vWrIHdbpe9bzkg6RCXy4XCwkKsXbsWVqsVFEWxNzTDMDyVwuDgIFtgQha/uOXOZ4J056K5kMViQUlJCe/6IWogop+enJzE0NAQaJrm9fPLtU0UN4f8ev/r+MKzXxD97JuXv4k1lWsUja0VSApKSwvSxx57DJdeeqmqYy4oQhbrzGEwGBR3SpaaQ+ZqeYkX8fHjxzP6EYuBLCRK0bly9+3xeGCxWGaNiIlSIz8/nxeFp6Y0uOXO3FkCWfwKBoMIBoMYHR3lVdGl+iZzt5svUJvoDQYD8vLyUFZWBpvNhqamJtjt9rR+fh6PB5FIJK37SGFhoaSHXjKZRJevC+c/fr7oZ57/0vP4u4a/k/0dZoOQAW1bUG3btg1msxmXXXaZquMuCELO1pkjlx8lGyGTqXpPTw/sdjtPy0uIVe7FJ7XIg+Rr3W43CgoK4HA40NGhbvmpEBKJBKtdXrlypWJbTO7iFxepOdW+vj62OCMajWJkZARFRUWaTNXVhpYLb9yxhfr5AR+a2hMzJq7HB1c2VlhYyBZjDPgHsPHFjaL7/c0Fv8HXVnxN8XHPhk+xlmmRJ554Art378aePXtU38e8JmQyFRbTEKsBMULmehE7HA7BBTOyrVyz9WxSO+6+i4uL0dnZCZPJhMOHD8vaj1wQxzeKorBu3TrZ5vtSIZZTpSgK77//Pmu2RNIeNpstLe0hlwTnYsoiG6Qs6nFN7VO3JdIxovgYD4zj6kNXwxv3Co51xzl3KPYm5kLO7E8p/H6/otlpNrz88su477778Prrr6u2LsPFvCZkboNDKRe9kpsjlRyFvIhtNmG/VrU1zEJETPZNdNVyQRzfMt3YPp8P3d3drNHQsWPHNCPjTMjLy4PZbEZtbS0bYZGpemoEOFfaRZ1pQhYDV/ERiUfwj3/5RxwaOyT42S9UfwE3tN0Ah8OBoaEhQcWHHMxGysLn8+UsR/va176G1157DZOTk6itrcXWrVuxfft2xGIxnHfeeQBmFvZ+/etfq3HIAOY5IQPSCxVItKrExJ1U9A0PD6O/vx/l5eU8L+JM+1TDgpNhGIyOjqKnp0f0IaC0YCOT4xvpk2c0GnmOb2cSqTpo7lQ91eVNqByXKyUjZG02mzVtcjpXS6fpJI0rX7wSz3c/L/j+eY3n4akLn4LFZGEVH8FgkC12IbO/1NLxbGQ7G4SshrHQn//857TXrr5aXGWiBuY9IUuFUkKmaRoUReHdd99FZWUlNmzYIDkFoVQyRwg5lYjXrVsnGo0rjcJIhMy9Qfx+P5xOJxiGYfvkzTcYjUZBJzIusZAuJDRNIxKJsDLBXBUKXGgZIQPKfneGYXDrG7fikYOPCL7fXt6O+5ffj49v/Dh7DsQUH1z1jFAaiZA093xmanCqFuajFzLwESRkqSBexENDQ2AYJqMXsRhySVlMTEzg1KlTKCsrkxSNKwU3sg4EAnA6nWx/vlwijLmqFxYjln379qG4uJhdSAyHwwD45vbchS+p0JqQ5eKXh36JLa9tEXzPkefA4asOoyK/Avv378/6QMqknuF2x56cnGTPp91uZyV64XBYM5njfDQWAhYAIUv9MS0WiyQ3tEQigb6+PoyOjmLJkiU4++yzsW/fPkVPdLmETPLTw8PDKC4u1pSICYxGIwKBAE6ePIl4PI7m5maegc5cgxal26Rys6KiIi3tIVTqbDKZJHsmzxVC/o+u/8AVL14h+v7hqw5jWcky9t+5nONMio9IJILe3l5QFAWXy8XrPMI9p7nab+oR8hxHtgiZoij09fVhfHwcdXV1OPvss9lpvFxdMIHUlEUymcTIyAj6+vpQXl6O2tpa9qLUEqQlT3d3N9ra2mRVEs4VotESYqXOxDOBeCZzqxG5i4gFBQVn/Dy9OfAmPvfM50Tff/Xrr2J99fpZORaiL7fZbCgpKWENmbiG9mKubuR8Sk0XEk/x+YZ5T8hyOhsLkSPxIp6cnERDQwM2b96cNlUj28ol5Gw+GKlETPLT/f39igtZpICUkkciERQUFKCtrU20e7QQSJoj08LMmSYiLSHkmUzyqUTtMTAwgHA4jEgkAr/fj+npaZbcc20QKgXHJ45j85ObRd9/5p+ewT8s+wdNj0EMqYt6Yp1HyIMvFAphcnKS1ywglahT702/34/W1tZZ+T5qYt4TslSkpiyEvIjFcmZqm9Rzu0dXVFSkLRSSNk5KkIkIie1nKBRCU1MTysvLcfz4cdnT02xpAy0rpIC5Wakn1ny1q6sLxcXFbGpoZGQkzeFNbvSXCQP+AXT8Trw46N/P/3d8Y+U3JH0frSBVZZGtWUAoFOItzFqtVhQUFOCtt97C8PBwTjphIae3qakpXHrppejt7UVjYyP+8pe/qJ7em/eELCdCjsViCIfD6Onpgd/vl+xFrBYhpxKxUPdosl00GpW9PyJhS/0+REEQCATQ1NSERYsW8RzI1OjFxwWJaAjRqClxmo9Rt91uR3FxMSorK9nXSDUiWfQSaxUl9fxNRabwsSc/huGgsKvZLR+7BT/Z9BNJ509rv+tcZW9izQIoikIgEMDAwACOHTuGQ4cO4eabb0ZnZycee+wxWfsQcnq799578ZnPfAZbtmzBvffei3vvvVdVpzdgARCyVCQSCYyMjGBiYgLLli3DihUrck53SN0umUxiaGgI/f39qKysFCViglw0xdzWO9FoFG63G9PT02hqahL8zkoWycS2iUQicLlcCAaDKC8vx/DwMILBYJqJ0GxN2+cCxGYsmaoRSdqDKyMjfhTc8wcAkXgEX3j2C9g3sk9w/99a+S3sPG8njAbpEj653ULkQgvZG3eGctttt+HEiRN45JFH0NDQgJGREdnjCTm9vfDCC3jttdcAAN/61rdw7rnn6oQsF8SLmEhs1q1bNysNS4GZi8Tv97MaZqnSOaX7Ix4YsVgMbrcbPp8PS5cuRXt7u+h3VkL+qYTM3R8h/lS3N2IiFAgEWBMhsmjDJepsN+p8M8iXm0snxkFCJkzcwoxgOIhtJ7bhjTffEBznMw2fwdP/9DTyTPLTIFoT8mwUhpD2TUajETU1NaqMOTY2hsWLFwMAqqurMTY2psq4XMx7Qha72Kenp+FyuVgvYqvViu7ubsUWnHIi5GQyicHBQfT19QGYKa+Uo2FWSsgA0N3dLSsdk0vKgqIo9PT0wOPx8PaXSkJcEyHutJ2rVhgbG4PL5eI1DiV/Srwp5grUMLnhnr/yReW4/Y3b8fDBhwU/W2+vx6/X/xqVJZWYHJtkF7/kRKRKG5xKhZbViwSBQEDWQrVcaLVOMu8JORXEi9hoNKKpqYldEIjFYoqN5qUSMiHigYEBVFVVYd26dThx4oTmBSWEGL1eL5YtWyarNZQSQmYYBn19fZiamkJDQ0PGBdFMEFMrxGIx1pJzYmIC4XAYBoMBBQUFiEQi8Pl8KC0tVWURTGuo5fbGMAx++f4vcdNrNwm+bzfbceSqI6gurGb9kkOhEEZGRtgO2cQvOduDTmtCBrRfC2AYRvUovKqqCiMjI1i8eDFGRkZ4wYVamPeETCIyrhdxa2tr2tNRaR6YbJtJvkbTNAYHBzE4OIjq6mo2NaHU8EcqIcfjcfT29mJ8fByNjY2oqqriLdhJgRxCpmka/f39mJqaQn19vaBEMFdwG4dyiwqIVvXkyZPwer0YHh5GPB4X1P7OpWhaDflftqKOg1ccREtZC/tvi8WC0tLStEUvbvXcxMQEa8NJijLI+Zstv2KtoFVK64tf/CJ27dqFLVu2YNeuXbjwwgtV38e8J2SGYXDgwAFYrVaeF3EqpHoMi20rROapRLxp0ybe1DCXxblM28XjcfT19WFsbIynnZ6enpb9AJByjNzIf8mSJaioqEB1dfWsEh/RqtpsNjQ2NrKLWmQRLBgMYmBgAKFQCACfZM6U0xuQGyFnK+p49KxH8dVzvipprEzVc8SGkxRlhMPhGYP6ri7ew05r/wm1wO0krxRCTm9btmzBV77yFfz+979HQ0MD/vKXv6h41DOYH2c4AwwGAzo7OzW9WFJd22iaZn0uFi9enEbE3GNTArEImVvWXVdXlxahqi1hI80he3t7UVVVxX7PDz74YM4srAktgnFJxufz8ZzeuCQ9Gwb3Sgj5g4kP8LEnPyb6/tMXPo1PVH0C/f39uR4erxqRwOPxYGpqChUVFaL5faVtorSW1AEz3d1zdSYUcnoDgD179uQ0bjbMe0IGZqZoWhIESXdIJeJckUrIiUQC/f39GBkZQW1tLa+smwulhJxahEJ8l91uN8rLy9Nkekojf7WQ7bcWIhkAbG411ZnMbrcjFothYmJCdUmeHELu9/dj5e9Wir6/8+934srVVwKYURFo2XFazISJ5PdTTZhSeyOKncPZMKefnp7WdEFPSywIQpYqhZJixi62nd/vx969e7FkyRLNiJiAFHhwHwA1NTWiREygRJ3BPXfcztHFxcWidp9nUnqWC1GK5VYjkQgOHz7Mq6RTIskTghRC9kQ8OOfJczAUHBJ8f8vZW3DT5pt445wJn2Wx/D4xDeJ2H0k9h+S/s+WFPB+NhYAFQshSIbelEteCk6ZpfPzjH9fspuSCeDDLfQDkkrLweDxwOp3Iz8/H2rVrMzZJPdMRspogkjKLxYJlyz50OxOT5ElVKhBk+u1D8RAueu4i7B3eK/j+Nzq+gZ3n7YTZmP7ba9kzTi5pkjLwgoKCrCZMFEUhkUjA6XTy0h5qkrQa3ULOFBYEIcutuMtGyISIh4eHWULcv3+/YgtOqUJ77uIZwzCyI3ElRBmJRDA4OIhAICC5YemZLs6YjX0rkeSlLiKSbVKvT4qm8C8v/wue63pOcN+fbvg0nr7wadjMws0IyLhaRshqzACFzuH09DSGhoZQWlrKM2FKreYkvRGVPHTU6BZyprAgCFkqsknfuLlaKSkCKSAKjUzjcEuryeKZEg9mOUqSQCCA7u5uUBSFsrIyrFq1SvJ+MrV90hpnstw6myQvGAyyXbIpioLVakUkEsHY2BgcDgcseTY41lLaAAAgAElEQVRse+9O7DywU3D8ppImvPr1V1Fiy04mWqYsyOKdVmPn5eWhvLycZ8LEMAxrwcmt5uSaMHF7I2aCTsjzBGIm9Vz1glpETJApr8s1G5JTWi0GoQW6VIRCIXR3dyMej6OlpQXJZFJ2CSjJxeuYgZB9JDG7OXToEE6dArY8/xhONd4muL3NZMP7V72PGof0El+tCVnLsYXuLTLLKCgoEDVhIg+7bCZM09PTPLKfT1gQhKzUJIhLxJnUC7lAiJAZhsHIyAh6e3uxaNEiQbMhJQuQmVIWkUgETqcT4XAYzc3N7AXr8/kU5Z0zRcihUAiDg4OsFlit/nTzCQaDAX19dtzwuBvHl/8D0Cj8uT9s+gOWWJZgrHsMocKQZEme1ot6Wi28ZZstpkKuCdOjjz4Kv9+P9vZ2nDp1Cs3NzTmlX37+85/jd7/7HQwGA1atWoXHH39ctK+lGlgQhCwVhJDj8Tj6+/tlE7ESTSn3IcBtWso1pBcCST/IuemEUhaxWAwulwvT09Nobm5Oq+RTkn4Qi5Cj0ShcLhcCgQCWLFnCdmEh0iixPKvcfc8VDbQYursNuHHnMbzC3A4sf0XwM/996X9jc82HBvKZJHlCLnlaLuppSchqyd7ETJgcDgceeOABeDwe3H777RgeHsabb76p6FwNDQ3h4YcfxokTJ2C32/GVr3wFTz31FK644oqcj18MC4KQ5fg2kMhUqLAiE3Jt4zQ6Ogq3243S0lJJvfKU7I/YbwLgGf8sW7ZM1PFNDbe3eDwOt9sNj8eDpqYmtLe3p+Xqk8mk4NRzIRkJ9fcbsOUBF3ZHtgLL/1PwMzVvPYsDT56P1LXTTJI84pLHleQBYDs7q11Fp3XKIpe0XCYYDAa0t7fDarXiuuuuw8aNG3MeM5FIIBKJwGKxIBwOY8mSJSocqTgWBCFnA/F8GB4eRmFhoSIPBiVtnMgNdfLkSSxatEhU1ysELrlKhdFoZCVFY2NjaGxsRGtra8YHlpJ8MCFxmqbR19eHkZERNDQ0sPtiGCZtNmE0GkXzrIRwiL+CkGpBq5tYDYyPG3D7g8P488g9YFY9CRg55zNpBEbWo3r0W9h+8ZW46Ps0pF56mVzyiJNhLpI8MWipFZ4tHbIanTxqamrwox/9CPX19bDb7Tj//PNx/vnnq3CE4lgQhCxGOFzznfr6eqxYsQIej0exM5lUcyJSYOF2uwEA9fX1aGxslLU/uUUeNE1jdHQUY2NjaGlpkfzQUaopnpqawsDAQE6LoGJtj7gLOdwmojabDZFIBB6Ph/VmOJOqC78fuGenF4923YfEmkeBypQF1eNfRs3pLdj+w3Z88YsJGI3q9Ek0m82wWq08ohaS5JGHm5CvRyZomZ+Wm0NWArVUFl6vFy+88AJ6enpQUlKCL3/5y/jjH/+Iyy+/XIWjFMaCIORUcDtIc13JpqenNbXgZBgGk5OTcLlcKCwsxJo1azA5Oako5ymVkLnaZSIlqq+vl7wfOYRMcuAulwsFBQWalo6nLuQQt7KTJ0+ynUlSTe4dDods718liMWAX/wuhPveehiRNTuBdWH+B7ovQJ1zK+789irUXvsuNm1Sds1lQippKpHkibnkaR0ha/37BAIBVSr1XnnlFSxduhQVFRUAgIsvvhjvvPOOTshSQVEUent7MTExIdhBWkz2JgVijm8AWPtPUum2evVqtsGiyWTKaN2ZaX+ZCJkrmSPaZYqi0NXVJWs/UgiZPGicTidKSkqwbNkySekbNTtPk4jYZrOhpqaG9angVoNxG15q0TIqmQT+/CyFm5//Lbwd9wEbvfwP9H8Mlce2YetVm3DpIwmYzQns35/TLjMci7RFvUySPG6HbK5LXiQSgdfrRVFRkeouebORslCrsKW+vh579+5luw3t2bMHGzZsUOEIxbFgCPn06dOiREyQqyeyEEESIrbZbIKVbmazmVUZyIFYkUeqUoMrmaNpWvWGpT6fD93d3bBarVizZg3y8/MxOjqa8cFGrA+1UkNwxxWrqBNaDDObzWnRtFRyePUNGv/2+/8Pg8u2ARtSerSNrkbRgbtwy5fPw1U7ErBa1Y+IU5FLpZ5Yqoi45E1PT8Pv92N4eFh1lzytCZmsX6iBTZs24ZJLLsG6detgNpvR2dmJa6+9VpWxxbAgCNlgMKCsrAzNzc0ZL9JcCZm7rdfrhdPphMViyerDrGSfqYt6XOOfkpISQaWG0oVAIUImlXwAsHz5cl6EdSa9LKREa5kWw4SkZfn5+YjFYmynbKvVyu7n1Okk/nnnf+JI6V3AGjd/R1NNsL5zJ35w3kX47gsJOBzaEzGBFnle4pJnsVjQ1NTEvi5XkpcJWjQ45YKQsVpR/datW7F161ZVxpKCBUHIAFBRUSHJllHp05MQss/ng9PphMlkSiMqIeTSsJRsR4x/CgoKMhr/KDHhT71wSQFJJBJBS0uL4Gr1fNACC8FsNgtaSobDYRw5coT1WYjFYggErLj/b268bb0faDrGH8i/BMa3bsWVa76Jm59mUFExe0RMMBt96QjkSvIyueRpfdzhcFiSH8tcxYIhZK1JgqIoDA4OorCwULBFlBhyIeRAIID9+/cjLy9PkvFPLiXNFEXB5XLB5/MJFpBwcabd3tT8nYnEjkSFsRhw46/ewa7BW0HXp7iwhcuAt7bg7xzfwK33JrBqVUQzz4dsmE1CFoLcxrVEkhePx9mcrBbH7/P55q31JrCACFkr+P1+OJ1OxGIxlJSUYPXq1bK2V0LIfr8f/f39YBgGa9askdz9QMk0LZFIIBaL4cCBA5I7Vc9XP+RMYBjgoWcO4573tiK6ZA/A1f9TBcC7P8C62Pfx0xsZtLd7EQwGcfJkEBRFwWKxwOFwsBEhKRVXM5+ZCi0JOZdjFsvpk35+IyMj6OnpSdObSzUOyob5bCwEfAQJWapHRCAQgNPpBE3TaG5uZv0n5EJO3joYDMLpdCKRSKC6uhoAcm5FI4ZkMon+/n4MDQ3BYDDg7LPPlnyDz9eUhRief7sL3/3Pn2N6yW4+ESfygP3fQV3fjbj7pmL80z8lMPM8qOZtz+3rxy0Vz8/PRzwex9TU1Izbm4rFLVrZb2pRks3t52e1WrFy5UxXFCFJXq6Na+ezOT2wgAhZ6kVEpG9iU01CivF4HM3NzWzeLBAIKFqckxIhh8NhuFwuhMNhtLS0oKysDBMTE/B6vRm3UwKGYTA0NIS+vj4sXrwYZ599Nt577z3VTIy0hppkccjdj6ufvBeugj8BS1Kq6w5fAceh23Hjt6vwL3+MZ1ROiPX1CwQC8Pv9GUvF8/PzFX0nrbwstPSxSH2IK5HkZWtcqxPyPAOJWFMJORQKweVyIRqNorm5mXdzcbeTi0zkFY1G4Xa7BY1/lOaexcAwDMbHx+FyuVBeXp6T1WemCJmrBjGbzbypvFqVdblG5/1TY7h61wN4L/F7wJFaXXcJjK/fiau+2ISb36CwaJEy3Trx8bVarWhpaWGPm6IoBAKBtGo6uaXiWqUstDYWyjZ2Nkketzt2qiTP5/NhfHxcT1nMBSi14ORGp4SIhcZSSshCY0kx/lGTkIlKo7CwUJafhhjEHjI+nw+nT5+G3W7HypUrkUwm2an82NgYW1nHJenZ6PxMMBXx4vt/eQQvjP4SjCUMcHfbfQHwv3fj7zvW4J7dMSxfLr+YJxWphTFcskmtphMrFU81XiLjaUXIWhoL5SJ5k9K4dteuXXjllVcQiURw8OBBrFq1Cj/5yU8UX+8+nw/XXHMNPvjgAxgMBjz22GPYvHlz9g1zwIIhZKkgKQtSfhsMBtHU1JRRVQCoQ5CJRAI9PT0YHx/PavyTy/4IEUxPT6O7uxtmszmrSkNOVV1qhBwKhXD69Gkkk0m0t7fD4XAgHo+zWlVSegp8qAUOBAKsppVhGOTn5/OIOtfFHS5C8RDu/p/f4DfHHkLC4gO4wWf/x4A921HPrMeDjxhw/vkR1fYr9ZxmKhUXeqAVFBQgFovB7/dr4vQ2n4yFuJK8HTt24L777sOKFSuwYcMGHD16NKfr6Prrr8cFF1yAZ599FhRFKSrwkosFQ8hSyYRhGDYCaWpqQkdHh6Rtc9EwMwwDt9uNkZERybafSvO0RqMRgUAAbrcbiURCkkSPfDc5NqbEzMbpdCIQCKC1tTUtzSMEIS0wmY4GAgHBfCshahIhSv0dKJrCr/Y9gXve/hkixjE+EY+uAfZsQ/HEP+KmLRQ6O9/F5s3qlsXmUjrOXQhLfaCFQiF4PB6erEytUnGtO5HMhrFQWVkZWlpa2FSR0nHeeOMNPPHEEwBm1gnUDBLEsGAIORtIvnZ8fByVlZWi/sBqIplMsosSRMkg9YJUEiFHo1FEIhEcP34cra2tktvYyO1OQtM0AoEADh48iGXLlmHFihU5nUuh6SjXvSwQCLARIkVRiMViCIfDoikPOknjzyeewm2v3AtPsg/gfi1PM/DqXTCc+DKuupLGrbeGUVaWxIED6qtG1PTyICCysry8PLS1tbH7ESsVl1vyrCVpzobTm9/vVyWH3NPTg4qKClx55ZU4cuQI1q9fj507d2pedLLgCTkWi6GnpwdTU1NYtmwZiouLQVGUpmTMNf6prq5GUVER6urqZLeukUrIXIN4q9WKzs5OWXkzqdE4ecD09/fLlsrJhZh72alTp1BQUMA2huWmPAoKCvCO9x3cs/fn6I+kmCz5a4DXfgocvgKf+LgBO96KYuXK5P99L/WJE9CGkIUgp1ScYZi0aJpbKq51hKy105vf71dFZZFIJHDo0CE88sgj2LRpE66//nrce++9uOuuu1Q4SnEsGEJOa7XOWThbunQp2traYDAYMD4+nlMuKNNNxjX+WbRoEatk8Hq9si9GKYTM7QlIctKHDx9W3WCIfC+3242qqips2LABx44dOyOVYiaTCYWFhbwyXpqm8XL3y7jzle046T/K3yBcDrx5M7D/X1G32IptT8Rw4YVET6wtZouQxZCpVDwYDPJKxYkihlwHWhDzfDKnr62tRW1tLTZt2gQAuOSSS3DvvffmPG42LBhCJiAWnJOTk4ILZ7kYDIm1Vcpm/KMk/ZDpRuZ6INfU1PBy0kpyz5m28Xg86O7uRlFRETZs2ACr1YpEIjFnCkP2De/DHW9uxVtDb/LfiDmAd34I7P0BrCjE5d8axEUXuVBQYMDp04U8xzftqv/OLCELgdvduaqqin09Ho8jEAhgeHgYkUgEhw4dYmceJJJ2OBw55VFni5DVSFlUV1ejrq4OXV1daGtrw549e7BixQoVjjAzFgwhMwyD7u5ujI+Po6GhQXQ6nYsnslAbJynGP7k8BLjgdquurKwUNIhXYjAkRMiBQACnT5+GyWTCqlWreLkzKaSvNREdnziOu965Cy+5XuK/kbAC+/4NeOsmILwIF14Yx7ZtYdTXlwLYIOr4FovF0NfXpwrxEMxFQhaDxWJBWVkZIpEISktLUVNTk6b9HRgYAEVRbCVdaql4Ngjp/9VGIpFQbfHtkUcewWWXXQaKorBs2TI8/vjjqoybCQuGkA0GA4qKitDU1DQrFpzEflOK8U+ukrlUg/hM3apzteCMRCLo7u5GNBpFa2urYLRxJkunB0IDuPP4nfir+69gwDmGpAk4dDXwxm2AvxbLl9O4774wzj2Xfy6EpvEkX2i1WuH1etHf369KVZ1WhKzlueeau4tpf7nFLR6PR7CruFCpuNY5ZLXPy9q1a3HgwAFVx8yGBUXI1dXVWX+UXAl5enoaXV1dMBqNkuw3gdwI2ev1oru7G3a7PaP1JoHSlEU8HkdXVxc8Hg+am5tRUVEhSiZnIuobDgzjvvfuw65jfwDNcH4/xgAc+xrw2lZgqhlFRQxu2h7FtdfGIacQ0Ww2s/4hgHBVXTgcZnPY3D+xabhWfhNaRt40TWeNYvPy8th2YQSpXcV7e3vZiJicp2g0OitVdPNlViKEBUPIUqGUkMmF5vf7sWLFClkruUr2GQgEEA6H0dPTk9EAPxVyUxZEwkaqBrN1qZ5teCIePLjvQfz28G8RpaP8N7s+D/zvNmBsxoHv8svjuOOOGCorc4+UxKrqiA6YyMuCwSBrcs8tbLFarZr6TWiphFAydqau4uSh5vP54Pf72c4t3POlRuQcjUazBixzHQuKkKVMpeXeIOFwGE6nE9FoFKWlpaisrJQtq5ETIZP9xWIx2Gw2rF27Vrbxj5R9MQyD4eFh9Pb2wmw2o729nVeAoAZyieT8MT/+/dC/4xcHf4EAFeC/2XMusOceYHCmjHXtWhr33x/FWWdpb3gkZC+ZTCYRiUQQCATYXGssFmN/t7GxsZyMhFKhJSGr6WWR+lALBoNYtmwZrFYrG02Pj4+zRUyZSsWlwOfzSfYpn6tYUISsJqLRKFwuFwKBAFta3dfXp5njWywWg8vlwvT0NFpaWlBeXo4DBw7IjlikSNhIPrq0tBQbN25Eb2+v5PGlIhAIgKIoFBUVybrBI/EIfn/097j/vfsxFZ3ivzm0YYaI3X8PwIDSUgY//WkM3/pWHLlwSK4pAGIkxF1HIGZO4+PjiEQibMqD5GW50aFcApyv1XRkbLml4qnFLWLR9Hz3QgYWGCGrseBCURTcbjempqbQ1NTEq0JTmu7I1Hma+FtMTExg6dKlvApCEu3KcWXLlLKYnp7G6dOnYbVaefloNe00w+EwTp8+zfraulwuJJNJXnNRoQWfOB3HH4//ETv27sBwcJg/6PgK4NW7gJMXATDAYGBwxRUUbr+dQnn53JDfpcJgMMBsNiM/Px+NjY3s6zRNs6STmvLgEnWmbs9apULI2FqaC4mRfbZS8UAgkLWr+Hy33gQWGCFLhZCeOB6Po7e3FxMTE2hsbGQLSbgwm82ixJoJZrOZ9XQloGka/f39GB4eRn19vaBMT8lioFDKIhQKobu7G4lEAm1tbWnTOjUIOR6Pw+Vywev1oqWlBSUlJUgkEuzYXCNysuBjs9mQX5CP1z2vY+fRnej19/IH9TbOLNYdvQxgZm7kjo4Q7r7bh898Zu5PTYUe+iaTSbCjRjZ5mcPhYFMeWi0WAtpGyErSIVK7iv/2t7/F/v37Ybfb8bvf/Q5r1qzB2rVrc2oKQNM0NmzYgJqaGuzevVvxOHLwkSRkrp44kUigv78fIyMjosRIoEbDUm5ZNTGIF7tIlRIy0VmTNIjf72fTIGLbKCVkbucR7oOMe9xc+RRRMiSTSbxw6gXc8/o96PKllDkHqmfka4euAegZeV9ZWRJ33EHhnHOcKClRl4y1lKdJ7ZItVKxBvDyCwSAmJydZ72Sr1YpYLIbp6emMU3gl0LpXnxrnWahU/JFHHsGuXbtw5MgRRCIR/PrXv8a2bdt4yhm52LlzJ9rb2+H3+3M+ZqlYUIQsxxOZoiiMjY1hcHAQNTU1kox/cklZJBIJtvyYW1adbTu5hEz25XQ6MTY2Juq3zIUSQibl1C6XC9XV1bzzxzAMaJpmp6gGg4F3k7/e/zq2vrUVB0ZTNJ6RUuCtLcC+64B4PgDAYGDw+c8P47vfHUNdXT78/tgZbbAqB7kSvZBRO03TGBsbw+joKG8KL1RRp2Tfs1FNpxUoikJnZye+853v5DzW4OAgXnzxRdxyyy148MEHVTg6aVhQhCwFpCrr8OHDqKmpEax2E0Mukrnx8XEYDAZZBvFyJWzJZBIejwejo6NoamqSZPMJyC8m8Xq9CIfDmJqaYsupgQ+F+TRNg2EYmEwmMAyDZDIJmqZxYPQAtr27DW8MvsEfkCoA3r1h5i/64aJMZyeNBx+MYs2afIRClQgEAggEApienkZfXx9PapZLz7ozHSHLgclkgt1uh8Ph4HUiISoPrj+FWPPVTDjT3axzgd/vzyki5uL73/8+7rvvPgQCgewfVhELipAzXfzcsmOj0YiWlhYsXrxY1vhyCZksopGV4o6ODln7kyNhGxsbg9vtZtMCDQ0NsvYj5XsRI3qGYWCz2XiRNyFesuBkMpnYB92xsWO46+278KLrRf6ACSuw/19nypxDH7qUlZQwuOMOrnriwzxiPB5HYWEhysvLWQ/lyclJXl6aLBymOpnNNrQi+tRFPe4UnpvyEKqoI+kRMQ2wVoQ8G5Wdaqksdu/ejcrKSqxfvx6vvfZa7gcmAwuKkIVA5Edut5s1/hkaGlI0ltQUAmmUStM02traYLPZcOTIEU32NzU1he7ubrY9UzQaxfDwcMZtUpEtZUFRFJxOJ/x+P2tE/+6777I3GSFiYIYcCFm4vC7c/fbdeObkM+llzu9fBbx+G+Cv4+3r8sujuO22CBYtYsAwBtC0IS3lQY6ZEAp5sBLpVKZIkbs4xsVsEKdakLqoJ1RRR9pFEY9prsG9w+FAIpFALBZTnPIQw3wyFnr77bfx17/+FS+99BKi0Sj8fj8uv/xy/PGPf1ThKDNjQREy9wJiGIY1/nE4HDyPYKWph2zbRaNROJ1OhEIhtns0AHbKLheZCDkYDOL06dMwGAzo6OhgK/koilLkLCdEyDRNo6+vDyMjI2mSPIPBgEQiwfs3+f+hwBDufede7Dq2CzSTcizHvjqjnPC08l5evTqJhx6isHFjAgxjRjKZZKNucizcKFwokuNKp7i+wCRSJNE0twSa5Fu1iOC0UkPkEsWKaYCJaoGmaZw6dYp9kHGleFJNhIQwnwh5+/bt2L59OwDgtddew/333z8rZAwsMEImIP4PNpsNq1evRn5+Pu99i8WCSER+7zSxNk5c72UhHwgxwssGIUKORqPo7u5GOBxGa2trmverGvabJL3T09ODJUuWpC3YJZNJ2Gw2HD58mL25HQ4HgkwQD+57EI++/yhiNF8eaOn5POL/fRcwupb3elERg9tvj+Of/zmBmZmzkf3uBMlkkvV+9ng8qKioAE3TaUoOoUgaEI4Uub39RkdHMT09jf379/Om8w6HIycFw1wkZCFwUx59fX1Ys2YNgJnrmpwjqSkPMeTS4FQq1PJCPpNYUIRM0zQOHjwIo9GY0f9BLTtMIYN4oWme0qkfV8LG7QqSyfwnV0Im/sfFxcXYuHEj6yqXumC3cuVKUBQFv9+P4alh3PXWXXiq7ylEaP6DzjH5KQSe3474YHq33q9+NYFt2yhkWochKSfycNi0aRN7vOThwDAMb/GQbEcUHuQ7csF1fVu0aBEYhkFHRwc7nZ+YmIDb7eYVIZDctNTpvJY55NlYeMvLy0NZWRmvVyK3Q7ZQTz+x3P1sRMhqtW/i4txzz8W5556r6piZsKAI2Ww2Y/ny5Vn7XuVKyKSV0eDgIGprayWrGeSCSNh6e3sxNDSEhoYGtLS0ZNyXUu1yLBZjH2ap/sepC3bkjzbS+IP7D/j5vp/DG/XyxiyPdmLqmR0IuGbKnLloa5tJT3zyk5kfHGRR1OFwYP369TzLUXIOUiNp8l+xlIfRaOSZ+aeeByGDHK6CYXBwkC3a4EbSQr4Ls7WoN5vjZkt5+P1+Xu6eRNFaFrMQUBQlq3XZXMSCImQA7I+fCUoJmWEYxONxvPvuu6iqqpIlmVOyL5/PxxKx1AapciPkWCyG3t5eeL1edHZ28qZ8XCIGPswTUzSFx488jh17d2AsNMYbr8ayAsG/3g3Pe/+EVCK225O4+uohfOELLlgsDI4fnyGzoqIi3tSX5OIpikJ7e7tkpzsxouUSNNFIA2D/SzqgiOWlhRQMsViMVTAQvwqTycQjaS0X9bSINpVG3mI9/UjKgxS2hMNh+P3+NN9kNe6hudLBJlcsOEKWArldQ7gtmpLJJDo7O9Py0lLHkXKDTk5Osh7IFRUVaGpqkrwPqdplmqbR29uLsbExLF68GEajkSVjMSJOJBP48/E/Y/s729E33ccbrzZ/KRwHtuLkM19ny5y5uPDCBHbsiKOurhxAOZLJJBtRjYyMIBAIsPtMJBKoq6tDW1tbTqWvBNyomIAQtN/vh9PpRFlZGZuXJtEc+d5CJCVmzUlIemBgAF6vF0ajEVNTU7zpfK4EpFXKQu20AjflkZeXB4qiUFNTw6Y8hNJC5DwplSvOJetYJVhwhCzFglNOhOz1enH69Gnk5+dj7dq1OHHihKKbQawfHxdkip6Xl4c1a9awOWo5yLaAyDAMhoaG0NfXx1YoksglNSdLCCnJJPGfXf+Ju9+6G11T/DLnxQVLsMp7C/53+zUYjKV3MWlsTOKBByhccAH/mIxGIzv15TaHraioQH5+PoLBII4cOYJ4PM4WgJBoWo02QIlEAi6XC6FQiG00kJqX5qY7uMctRtJmsxmlpaXsg62npwf5+fmw2+1pOVeumZDcllFaEfJsuMhlcnojSpiRkRFEo1G28SrX6U3s+IhUb75jwRGyFEjJs5KeckajkScry0UyJ0bI4XAY3d3diMfjPPMfIkOSg0wRAom8y8rKeKXbpACFRIeEcBiGwcvul3Hnm3fiyDhfR11uL8fni3+MV392Hf6fKz1nn5fH4Ac/SODHP44jk2e4z+dDd3c3HA4HNm7cmBYRc3O4Pp+P9Rq2Wq2suqOoqAg2m01SdJRMJjE0NITBwUEsXboUy5cvT1v4S81LK108JO8JERDXTKi/v5/Nf3IjaTE/4PkSIaeOLUaYYnJF0niVzDiIQVeqysNisSwIpzfgI0rImW5crkE8cS3jIheDodQmjxRFweVywefzoaWlhTf9Jduo4dsQCATQ1dUFi8WCNWvW8NIthDQikQj2798Ph8OB4uJiHAscw30H7sPe4b28sYryivCttu/B+eQPsOv5stRdAQA+/WkaDz5IobVVfKZC5HuJRCJjnlgoh8swDJvDJSmPSCQCi8XCkrRQR2lSRFNeXo6zzjpLck4ekLd4SI5b7DoRMhMi34nIzIgfsNls5pF0QUHBvOxEkkgkZKf5SONVrsqDtIoiSpienh7s3r0bb7/9NiKRCJ5//nmsXbsWDQ0Nis7RwMAAvvnNb2JsbAwGgwHXXiYzlcAAACAASURBVHstrr/+etnjKMWCI2SlFyrXGa25uRnl5eWCY+ViMMRdTOrt7cXo6GhalCa2jRKQxbFwOIy2trY0C0NugcWmTZtA0zTedL+J773yPbwz9g5vLJvJhitXXIPSEzdh5zcXIxRKP97q6iTuvTeOSy6hIfYzkO8+OTnJGv/LhcFggM1mg81m43nncgtAuIbwJAViNpuzNqSVgkyLh+S8er1eTE1NoaKigl2v4CpUhBYPyXfinpN4PM6SdH9/P8LhMKLRKMLhMMLhMPvgUWNhbDbM6XOFkBJm7dq12L17N3bt2oXDhw/jiSeewO23345169bJHt9sNuOBBx7AunXrEAgEsH79epx33nlYsWJFzscuaf+zspc5CoZhWFnZxMSEJGe0XB3fBgYG0N/fj5qamqxyOaWEzDAMuru7MTExkaZZFluwOz5xHHe9dRf+5vwbbyyL0YLLl1+OdeF/xUM/6YDLlR7lGI0Mvv3tBG67LQ6xDjqk2KSvrw+1tbXYuHGj6tFYagEITdNwu90YHx9nF+0++OADADNqHG40rRZZkMifpmmsXbsWNpstrcKQHJuUxUOLxcLLSwPAyZMnUVJSgmQymeb4xlV5yM2pztdOJOShu2rVKtxxxx05jbV48WK2FN/hcKC9vR1DQ0M6ISuF1AjZaDTC7XZjdHQ0qw8yF0oImSxafPDBB6iurpZkvUmOUa7b29DQEEKhEKxWK+87iS3YubwubHt7G/5y8i88vwmjwYjLOi7Dvyy/Cb/Z0YLvPil8qaxcGcT3vncKTU1+9PfzSY5EbSRPXFRUhA0bNqiinMgErn+J0IOPdO0IBAIYHh5mu3aQ3CT5DnKOk/hCE6e91P6EmfLSchcPGYZhiZf7GjFbInnpeDwOq9XKM1vKlGvXkjQzdQtRA1q0b+rt7cX777+PTZs2qTpuJiw4Qs4GYhAfDAZRVlYmWd9LIJeQiUqDpmk0Njaivr5e8rZSHy5Elud0OrFo0SIUFBSgrq6OFxWnLtgN+gex/d3tePLYk2l+E5csvwQ3bb4Fe3e344vX5mFqKv04SksZ3HknhSuuMMJoXMHm9vx+P0ZHR9n8MOkJuHTpUlRUVGhOxmQx1m63pxWTEAh17SBdTfx+PytxJHlPLkkLKTympqZw+vRpVFZWYuPGjVmvp1wXD4X6LHLz0gTcXLuYeoGYLZGFXS0jZC1Lp9Um5GAwiC996Ut46KGHZrVx6oIjZDES41pULlq0CIsWLcLixYtlP7Uz9cfjgpj/AEBHRwcmJyc1iRD8fj+6urpgtVpZr+WpqSl2+pmanhgPj+P+9+7H7w7/DhRN8cb6x6Z/xG0fvw3G8bX4t0vzsHev8PFedlkCd99NgbMgzsvtVVVVsXni+vp6GI1GBAIBDA0N8abWhOTUkCuRBdJQKITW1lbZNxHXPY6AKDz8fj8bdZJu4A6HAzabDRMTEwCANWvW5NSCXuriIdHwkiIlqXlpbsTOVS/09fWxHhWkG8n09LSi5quZoHXp9PT0NJYtW6bKWPF4HF/60pdw2WWX4eKLL1ZlTKlYcIQsBNJluaioCOvXr4fVasWJEydykq+Jgev4xjX/8Xq9OS3QpSISiaC7uxuxWCytTx7xwCA3gMFggDfqxUP7H8KvDv0K4XiYN9an6j+Fn57zU6wo2oRt2yz45S/NoOn0B1t7+0zJ8znnCKdRUvPEZ511VhpJkKm13++Hx+NBT08P4vE47HY7T8YmVWucScaWK7gKD2J8Tkja7XZjaGgIdrsdNE3jxIkTPK20kMWnXHAXD8liqMfjQUdHB6u2EFN4ZMtLC3lUkFkBab7KMIxqTQBmg5DViJAZhsHVV1+N9vZ23HDDDSocmTwsaELmFlqkur7JrdYjEEtZJBIJuN1uVj3Q0dHBuyHNZrMih7lUEJOhqakpNDc3Y9GiRWkLdg6HAwcOHJiJcuwmPN3/NB499ij8FL832FmLz8JPP/FTfKr+XLzwggmX/9iC4eH0Gzg/n8GWLXF897sJiAWzxGGvpKQkY56YO7Xm+hgLaY1tNlsaSecqY8sVZJ9VVVVYsWIFS3hE4UFSHsTik0vSmQobMoEEFIsXL8aGDRuypjxSFw+B7CRtMpmQl5eHkpISVgtM0jjE7Y3bBIBb1CK1qk7LKjq1jIXefvttPPnkk1i1ahXWrp1xJrznnnvw2c9+NuexpWDBEbLBYEAwGER3dzeSyaRgl2VAPU9kbpPPTIuDuUjYSE6RGBrV19djyZIW3H+/BTfeSMNu5+ceW1paUNNQg1/s+wUefvVh+GI+3nhtJW3YsnELLuq4CIODebj44jz8v/8nTGaf+1wC998fR329sKaYROrJZBIrV65UVFKeSWvs9/tZw5poNAqr1Qq73Y5AIACz2YxVq1Yp2qdcRKNRdHXNVCkKpSfELD5J/ravrw/BYBAGg4ElsmwKD7JPg8HAKjbEICUvTUia62NNFg+B9ChWLI0TjUZ5i6Kp3sliTQC0hFqFIeecc84Z9cVYcIQcj8dx8uRJNDU18aZkqchVT8z1DK6urs5qNKSUkI1GI1tWXFlZiU2bNqGvz4xNXzoAd9MWHLvhF3j6kWYAMwt2CSaBJ448gR3v7sBoaJQ3VktpC360/kf4VMWn4J0K44c/nMKTT9aDotIJoa4uiQceiONznxM+5kQigZ6eHkxNTfHM+NUCN/9JIjaapuF0OjExMYGSkhIkEgkcOXKEdV4j0bSaZJBMJtHX14exsbGMnbuFkFpKTb6DkMKDS2YFBQUYHR3FyMgIOwtSgkx5aXINcwk7FAqhqKgIiURCVGvNraoT0oBzjYTIukJhYSFbCarVLGYheCEDgEHm02BeWCpJWXQbHR1FKBSSZdwDzFx4Bw4cgNFoRHFxMZqamiQtSk1PT2NgYAArV66UvC+fz4cDBw6goqKCbQW164U+XPf87Yi3PT3zIec/4P61L+Caa6N46uRTgsY/DcUN2LJ5C77e8XWYjWa89poRP/hBHk6fForkk/jylwdw7bVjqKoqTJOAMQyD4eFh9Pf3o66uDjU1NZpHQqkyttraWh5RcNMFfr8f4XAYZrOZl+5Q0u2CpAqqqqrQ0NCgmQIhtfrM4/HwlCDc1IAWIAvDDocDjY2NrB8M1wwrW8pDCIlEglXe9Pb2wm638/LShKzVUN6cd9552LNnT85FPxpC0k2yIAmZoqis047JyUl4PB60tbVJHpdcuH6/H5s3b5Y1VQ4Gg3C5XGw3hkwIh8OsVI6maaxatQoRJoYvPfQzvJt8BDBz1BG0GVVdt8Hx8T/C6e3mjVNdUI0bN9+IK1ZfgTxTHkZHgZtvzsPTTwtH8h//OI2HHqLQ3v6hhM3v9yMQCLCypUgkguLiYjQ3N89KqoArY2tubpasyCBKAnL8oVBIck43Eomw7bFaW1tnxWM3Ho+ju7sb0WgUbW1tyM/PZ/O35HsQvwvubECqh4cQSOGMz+djDZa4EEt5EEgl6UQigaNHj2LdunXsw4fMEoLBIBKJRFaD+2z4xCc+gUOHDs3ljtmSvsyCS1lIhZyUBVfR0NraiuPHj8smIykpi3g8DpfLBa/Xy3pbHHz/IHa++yi2vX0f4hYP6XA0g0QezIY8jK34KcY4/vDl9nL8cNMPce3aa2G32EHTwG9+Y8bWrRZMT6dfF4sWMbj7bgqXX05Kng1s7nDJkiW8B0RdXR1isRiOHz/OSti4kahaOmNyLoLBoCIZm5CSQCinS/KkhKA9Hg8mJydlpyeUgqtMWbp0KaqqqlgiIoufXIUH1xWN5NWVpGxIZ5glS5Zgw4YNot1ngNwXD7mpCq48MnVRNxgMCjan5fb0EzpOEnzNd+tN4CNOyNlUFhRFwe12w+v1pika5CITIXMXBhsbG9mo/SXnS7ju1RswTPUCQjxnppDAh9FysbUY12+8Ht9Z/x048mainUOHjLj+egsOHRLO3V15ZQJbt1IQ4h6SJybfPzVPTPKOpHmo2+1miymIw5lckubK2Mi5UOtGE8vpknyu0+mE0WiE1WrF6Ogo6xWhVml1KoLBIE6dOoXCwkJJFYxirmiklVYgEMD4+DhP4UFImswGKIpiH67ZFgqFIGfxkFzvkUiEV3WaqQmAWHNarnKFG0kXFhby0irzHQuSkKV4IlssFtEImdttWS1SEIrISbGKy+VCdXU1WzV4dOwobvzfG/Fq36uSxi6wFOA767+D6zdej1LbDNn4fMDWrRb89rdmMEz6sa9alcTOnRQ2bUrXFBPP5IGBAdTX16O5uVnw+xsMH0bS3GiH6IwnJydZnTGXpMWKQc6EjI2iKPT29sJkMuHss8+GzWZDMplkiUBo4Y18B6WVZ9xUgZgKSA7y8vLYYicCkrLhzgYSiQTi8TiqqqpQV1en2mwm0+Lh1NQUnE4nampqeOZa2dppke+VqTnt0NAQ3njjDfz2t79FLBbDzp070dnZiXXr1knuMpOKl19+Gddffz1omsY111yDLVu2KBpHKRYkIUuBGEES8/bUbsupkNsvLbVjNSmpdjgc2LBhA6xWK0aCI9j6xlbsOrqL5yshhjxjHr7Z/k38ePOPUVta+3/HBTz1lAk33ZSHiYn04yssZHDbbXF8+9ukyzMfhBTLysqwceNG2aQjpjMWKgYhJG21WjE+Pg6DwTBrMjau61yqSoQs2KaWVpO8+tjYGJxOJy9lI8X/gtt5pq6uTvRBpwa4KZtQKIRTp06hqKgIVVVVCIfDGBoaUv1Bw0UymWQLpEgNALfyMLU0XKpemtucFgDa29vx2c9+FldddRUcDgeeeeYZ0DSNT3/607KPmaZp/Nu//Rv+53/+hzXA+uIXvzhrxkLAAiVkKRc512uY6wVBorNMN5aU7h9iCIVCOH36NNvluLCwEJF4BNvf3o77996PUDyUdQyL0YJvdHwD17Rdg/xEPsbcYxigBjA2VoaHHmrB/v3ChHbxxTNtlJYsSSf7UCiE7u5uGI1GrF69Oqcy4FSIkXQwGGQjRRIxE7N6QnJadIEgpLh48WLJrnNiDVC56giu/wU3r56Xl4dIJIJTp07BYrGIemyojWQyiZ6eHnbxmjxguBFnpgeN0vJ20gihvr6eN7uUYlsq1pg2E0lTFIUlS5bgqquukneCUrBv3z40NzezJdhf/epX8cILL+iEPJvw+XzsKn5nZ6ckIiLRtRxCpigK0WgUx44dQ2trK8rKypBkkvjz8T/jttduw2BgMOsYJoMJl628DFs2b0FDcQP7eigE7NhhxsMPWxCPpz+M6upiuOcePz7/eUvajRWPx9HT08Oa5M+GljNVxrZq1Sp2BsH1jujr6wNFUYrLqlMRDodZo/7Ozs6cZWSZUjaBQABTU1Po7e1FKBRCMplERUUFqqqqZqXwwOv1oqurC9XV1bzqvlSIPWi4M5re3l5W4ZGpcpKbn163bp3k86skL022MxgMqhWFDA0Noa6ujv13bW0t3nvvvZzHlYMFSchSIuRQKIRwOAyXy4X29vY0yU8mEG9jKeDmo00mEzZt2gSDwYB3Bt/BT/b8BAdGDmQdwwADvtz+Zdz8sZvRUtbCe+/FF0340Y8s6O8XasTJ4Hvfi+DKK8cQi03j6FE/r0cdRVGYmppCY2MjWlpaZmVRJJMbWybvCFJWTdod2e12XiSd6eanaZqNFLn+IlqAOxvIy8vD1NQU6urqUFVVxaoIuKXhaknYCOLxOE6fPg2KohQbHonNaIjCg1s5SRQeyWQSHo8HTU1N7G+XC+Q44r300ksYGhrKeZ9zAQuSkDMhFovB6XQiEAggLy8PnZ2dsrWL2QyGgA/lTD09PWw++r333kOvrxe3vX4bnj31rKR9/UPdhbjrM7ego6KD93pvrwE//rEFL70k/BN+5jMzbZSamwGg6v/+Pizs6OnpgcVigdlsRl9fHyYnJyXnQpVAqYxNrKw6Go3C7/fzSJpEcNx0B0kl1NTUaGKKL4RYLMbaj3JJUahlE1FHcAmO+zuI9dVLBWkU29vbmyafUwNiCg+/34+TJ0+yBR+9vb0YGBhIa6WlxnlPJenx8XH88Ic/hNFoxM6dO3Mev6amBgMDA+y/BwcHUVNTk/O4crAgC0Nomk6LYImEi3QGqaqqwoEDB7BmzRrZ+bxTp06hoqJCVKdKNJ7cSj5/zI/vP/d9PDf0HGJ09krCushn8eRVN2NjbSfv9VgM2LnTjB07LIhG02+4xYuTuO++OC66KL2NEslfm0wmtLS0sETBnaKSv9QFq6KiIkU5c4ZhMDg4yMrYqqurNYnEuSRNiJr4XVRVVaG0tFRwmq32MZDv2tTUxCMuqeCSdCAQQDgc5vUKFHKSC4fDOHXqFGw2G1paWjT3nAY+/K5DQ0Npmm2uwsPv9yMUCvH03kSyplRFwzAMnnvuOfzsZz/D1q1bcdFFF6nymyYSCbS2tmLPnj3sA/xPf/oTOjo6sm+cHR/dSr1kMslqjJPJJGvKU1dXxyu7ff/999mqKDlwOp2s7y8XwWAQXV1dMBqNaG1tRUFBAegkjSeOPoGtb2zFeHg869gG93m4ofNW3HnthrT39uwx4oc/zEN3t1DJM4N//dcEbr01jtTsC3GIm56eRmtrqyRXLLJglVqtV1BQwIvgMpE0V8bW2NioqUE5AUlPEI8Nm83GK6tOTRWoRdKkirOkpATLlv3/7Z17VFTl/v/fA8NlABGQS8pNZIBRROUySR3168rUb+k5lnr0dCwx8rjqpOKpvP+OllZi3nVlaRc7pWXm6nSx8lSWx1K5hagoN7koICAwMFeY6/79wffZ7RlmhmEue1D2a63WytueZ4D57Gd/nvfn/R7lVMkeczScFGmix9VoNFAqlRg9ejRrXg5KpRJlZWUIDAxEfHy8Te+V6L3J+1AoFABA/zyZpsxYoqWlBS+88AL8/f2xd+9eu30+LPHtt99i1apV0Ov1yM7OxsaNG5116cFdkDUaDZqbm1FTU4OIiAizBeHq1auIjY3ttw60rq4OXl5e9OMMaYOQx3HywTh78yxW/7gaV1uv2nDRKQgueQUnd2UiM9NYG9zYyMO6dV74/HPzP6wPPNAz8jx2rPG3hzlkERsbi+HDhztUeJieC6TAEdkUs0hrNBraAS4xMZEVGVtffhfMv8d0kSNF2sfHx+hpwNYizWzFiEQiu/Wv/aWtrQ0VFRUQCATg8/lGZj7MXagzWzTEaOnOnTsQiUQOH6QZDAZaU0z+s6TwMBgMOHnyJHbt2oWtW7dizpw5d9sgyOAtyF1dXSgoKKDv4JYOfMrKyhAeHt7vEdmGhgbo9XpERUWhrq4OLS0tdBuE5NSt+2kdvq76uu+L1T8A/LQVowVibN50BcOHGzB06FAEBgbC1zcQ778/BNu2eZlNeSYjz4sW6WH6uWtra0N1dTVCQ0MxcuRIlw1ZMGVTUqkUbW1t0Gq1CAoKQlhYGP2hcuWQh1KppFNTEhIS+t2CMi3Scrmctvpk3miYh25kqKe2ttYpNztb0Wq1dJK4SCQyMtNhjoaTVgFRgpACZ2+rQCaToby8nP55clUvnikllMvlqK+vR05ODvh8PgQCAdasWYNp06Y55eCQZQZvQTYYDJBKpX3uzCy1Hvri9u3baGlpgUqlQmRkJB1TJFPLkHshFwcKD0Br6MP8vjED+HkLcON/sWiRHvv3a+Dr+/sY7A8/6PHqqxGoq+v9Hng8Cs88o8PmzVqYul6SPjGfz4dQKHSqntgSprtT4n9BChxJn2DupJ0REcQc7ba1FWMrpoduMpmMLtK+vr6QSqXw9/eHSCRiRVPM/Br35wZA7D6Z3wsAvYZBLH0vSJKITCZj9QkA6PkcnzhxArt378bKlSsxbNgwXLp0CTExMVi2bBlr63ASg7cgUxQFjUbT598zbT3YQltbG65fvw4vLy/af0Bv0OPDqx9i8383990nbprQU4grZ8PTE9i2TYu//11HH8Ddvs3D+vVeOHnSfHtCJJJj+fJyTJigQWBgIL2b5vF4qK6uhlwuR0JCgtMTeC1hqxsbeTxl7kIB9Gp32LLzYhanqKgoREVFsbI71ev1qKqqQnt7O4KCgmhtOVMZ0fNk47h8jUlXVxetn7bnCcAU5veC7ERNPZmHDBlCf29JC4jNFkFTUxNWrVqFkJAQ7Nmzx+l+225g8BZkwDZP5IaGBuh0OowcObLPvyuXy+kPRUREBCQSCcaMGYPz9efx0o8v4VLLJesXaEkBzr4MlD8GUB4IDqbw4YdqPPRQT79YowHefJNvsT0RHEzh5Ze1ePppHTw8flcUSKVStLa2oru7GwEBAQgPD7fL1Ke/kN6pXC6324/B0u6NeeBm2gclB6f9teN0FOKNPGLEiF79adN2R1dXl93yNSYUReHWrVtoamqih4lcBfN8oLOzE62trdDr9bQZk7Pd/Kyt45NPPsGBAwfw+uuvY9asWXdbr9gSg7sg2+KJ3NLSArlcDmGPWNcsJLRUpVLR46dyuRx51/PwUfNHOFF2wupr8FqTQf28GSibB1A9H2KRyIATJ9SIj+9Z348/emD1avOG8QCweLEOW7ZowAhoAEVRdJ84LCwMsbGxvQ6r+quKsAVXy9jMncaTQYXu7m5oNBqIRCLWFAXMGKX+eCObtjtIkWbebKwVadKzDQkJQVxcHCtGS0CPtre6uhojR46kfS+YCg/mYJGzx9tv376NnJwcREREYNeuXfdEAggDriD39d7a29vR2toKkUjU68+YumWhUIiwsDDweDx067qx4/wO7MrfhW5Dt8Vrh1IitJ18Gbj+Z7oQA8DMmXocOaLG0KHAzZs96omvvjJfJMePN2DPnt6ObAqFgg5vFQqFFouEqXTNkirC1g87CTINCQlhTcZGBmxqamoQGBgIDw8P2seYWRScNXxAIHLJpqYmp3kjk/MBpnyNaIyZioKamhrI5XJWe7ZqtRrl5eXw8PBAUlKSxSLLHG83Nc5nvo/+SAkNBgOOHTuGN998E7m5uXjkkUfulV0xk8FdkLVaba+EA1PMxSoRqRiJKGI+nn534zu8+OOLqOmssXjNpBARQq/9P5w//BeAMi50K1Zo8dprWqjVwJ49Xti9m292uCM4mMLmzVpkZ+vArJXEn1kulyMxMdEu2ZGlXq61NgEzyJQtGRtgvT1BFAXkPSgUCiMPYFKk7flgd3Z2oqKiwuUKFcDYy7i1tRVyuRy+vr4IDQ2l34crA0OZBvlk42HPNUgLjXxPmFJC8j0x11tvbGzEypUrERkZiZ07d7J29uEGuILcV0EmZjOpqal0C6CqqgqhoaEYNWoUvQO8Kb2JF398EaeqTlm8VlxAHOaGLsaPe5fjcomxWJ3Pp7B/vwaLF+vx+eee2LjRC/X1vXdzPB6FrCw9XnlFA6benezWbt++7ZKxWGYvVyqVGiVpkMGDpKQkp4vwLaHT6eiT/f7ceJhFmsi+PD09jYqCtSKt0Whw48YNOkaJrXw2sjvl8Xi0O5ppRiBJz3Bmke7q6kJZWRn8/PwgFAqd+sRDVCrM90EOQO/cuYPGxkZ0dnbis88+w44dOzBz5sx7cVfMhCvIfRVkjUaDy5cvIykpyUjHSqRiOoMO+wv2Y8PZDRavkRyajLUPrEWa71zMnydAeblxoR0yRIstW64hIsIXe/bEorDQvAwtI0OP3bu1SE//fc3MPnF4eDhiY2NZ6SUy2wRkt0ymw5hqAmfv3Jh+DDExMRgxYoRTzHZMi5vp+xAIBGhqasKtW7dccsOzBHP8uK90aUvTesw2ga1PBMzDQpFIxOquVK1W4+eff8b+/ftx+/Zt+Pj4YNiwYcjNzUVmZiZr63ADg7sg63S6Pg2AVCoVLl68iMDAwF5Kgar2KqS8k2Lx306ImIC1mWsxO2E2rl7xxOOP+6KlxfhrHh9vwMGDGhw96oGjR73MJncMG6bH5s1dWLKEB0/P3/9cLpejqqoKPj4+iI+PZyVok7yuJRmbVqs16keTnRuR3jki+SIqFn9/fwiFQpcrREhhk0gk6OzsBJ/PR3h4OIKCgmzOpXMEhUKBsrIyh0atme/D9GZj6YmAvG5wcDCrh4VAz5Pev/71Lxw+fBg7d+7Eww8/DB6PB4lEQqeE38NwBdlSQdbpdKipqUF7ezs0Gg2mTJliNIHVpe1C0ttJaFW19vq3D0Y+iBczX8TMuJ5HrHPnPLBggQ/kcuOvd2qqHpMmGXDkCB8KRe/vBZ9PYckSOZ5+uh4GQwfUajUEAgH8/f2hUCig1WqNTMVdjb0yNuZBFVETmI4hW7uZEJ8NmUzmlDgjWyE/A1KpFElJSb08L1QqVb9UEbbSV9Kzo1h6IggICIBarUZXVxeSk5NZL363bt3CihUrEB8fjx07djj9fd8FDO6CbM7xjWk0FBMTg8jISOTl5eHBBx8E0FOM9Xo9KtsrkXYkzejfzoibgdWZq/Fg1IP07333nQcWLfKBWm1+rLmtzfz3YMYMPXJzNUhK+v3LST6ozc3NGDJkCHQ6nVH6xNChQ50Wr8PEFTI2pusa09CHOcji5eVFHyaxOXpsGqMUGRlptadserNxZAiEmfQcHR3NWs+U+F74+fnB09PTagiqszEYDDhy5Ajeffdd7Nq1C9OmTbvXe8WW4AoyKchksov0YpmSrQsXLuCBBx4wijTn8XjYfnE7vqv5DmkRaXg+43kIg421yl995YmnnvKGTmf7D1dSkgHbtmkwc6Zxn7i1tZU2QYqJiaEfIy3J1pi7Nlun28xBZGzk8dVVMjZTa0yJRAKlUglvb2/cd999tDWmq4cOmDFKiYmJdulnzemLrXleAMZJGmQ3zgY6nY7OtRs9erSROkan0xm9D2KRadrucKRI37x5E8uXL4dIJML27dtdKuHLzs7GqVOnEB4ejtLSUgDA6tWr8fXXX8Pb2xvx8fE4cuSIO1Ucg7sgEwtOEtFETpKZHwaKopCXl0c7vtm62/n++542hbm4taLfQQAAGbVJREFUJHOEhFDYsEGLpUt1YNYc0q/19fWFUCi0KfKGyNakUin9gSKaXLL77Otwp7u7G5WVlazL2ExN6j09PV0+yAIYu5S5IjHEdCCHaUyk0+nQ3t4OoVDYb88UR2Dm2tl6OGpOpWKP3ttgMOC9997DkSNHsGfPHkydOtXlu+Jz584hICAAixcvpgvy999/j4ceegh8Ph9r164FAGzfvt2l67DC4C7IKpUKV69ehV6vR2JiYq/MMLIjlslkaG1tpQXufn5+RodUpgWhvJyH//kfX7N9YVO8vSk8+6wOa9ZowawBRF7V1dWFhIQEh/t5zA+SVCqFSqWiD0lIm4DE29fV1aG1tdVpww62QFJKbt26ZbU94exBFqDHk7myshIRERGIjY1lJTEE6Hn6IIMWfD7fbKKJo5l+5mDuxkUikcOvYU7vba1I19bWYsWKFUhOTkZubi5r0kGgx5tm9uzZdEFm8u9//xsnT57EsWPHWFuPCYO7IHd3d6O9vd1ISsTM4aIoik6yZf45cSkjO1Bmi2Do0KGYOzcMFy9aLwg8HoWFC/XYtEmL2Njfv2QGgwG3bt1Cc3Mz4uLiEB4e7rKdAzmBl0qltLZYq9Vi6NChiIqKQlBQkEsKginEuD0wMBCjRo3qd1vCnkEWoGfXymwTsOF6R9ZrLunZkg+zs4o00w6UWMG6ClObT4VCgfXr18Pf3x83btzApk2b8NRTT7Hy88XEWkH+4x//iIULF+LJJ59kdU0MBndBNnV8Iwd25gqxNQwGA/2D19CgwMMPp1v9+7Nn96R2pKT8/qUiPeza2lrcd999iI6OZk1uxJx2i46OpsdepVIp/UTALAjO6uMS314yVOLMU3UyyEJumqa7tq6uLty5cwdCodCuGCV7YSY9E0tWa5j21slTGknZttUroru7G2VlZfD29kZiYiIrEU5Mampq6Gm78ePHo7S0FGq1Gp988gmr67BUkF977TUUFRXh888/d+eBIleQiZ+F6YGdvd8UigJiYgSQSIz/PY9HYcqUdjz3XAcmTuzR5ZLdgUwmQ1VVFQQCgVWzfGdji4yN+BKQwsbs45K2TX9bBBRFobGxEfX19S7N0DNFp9OhubkZtbW18PT0BI/HM2rbuHIEmZn0LBKJHNqNWyrSzBsn8bywlmvHBnq9HocPH8axY8ewd+9eTJkyhdXXN8VcQf7ggw9w6NAhnDlzhrWzEgvY9IN3z6ZOy+VySKVSBAUF0UXY0Q8jjwccParG4sU+aGvjITragLlz9XjmGR0iIz0gk3lBJpPRMe96vR48Ho8uTGyZ8TBlbGQU1/z7+T3RmcS9MxNAbt++TZvLM9s2lg52pFIpKisrERgYCLFYzMr7BYwPC1NTU+nTfOYgy507d2htsbO8i12R9MxMd2YmVJMnm/b2dtTW1kKtVkOr1cLf3x/x8fGs64pv3LiBFStWID09Hb/++qu7i51ZTp8+jTfeeAP//e9/B+T6zHHP7pALCgrw4osvQiqVQiQSIT09HWKx2CiW3V4MBkChAMx9BvR6Pd0njoqKMlISmPajnZ151tHRgcrKStqy0VkFkVhiMn2LiY516NChEAgEdIx9UlISaw5lzIJoq5bZ0UEWgjuSnoHfFSMtLS2Ii4ujD6blcrmRbp3spJ29Lr1ej7feegvHjx/H/v37MWnSJKde316eeOIJnD17Fm1tbYiIiMArr7yCbdu2Qa1W008OmZmZePvtt921xMHdsiBotVpcu3YNeXl5KCwsRElJCTw8PJCamoq0tDSIxWJaguUIpn1icz1EZj+aKVljDkzY81jtDhmbTqeDVCpFQ0MD2tvb4eXlZVQMSNvGVe0KpVKJ8vJyCAQChwuipUEWptqG9HGZErqkpCRWda3EI9lSrh3zUJrZgjI9J7D3Rl1ZWYmVK1fi/vvvx9atW11+UGpOWyyRSLBw4ULU1dVh5MiROHHixN3im8wVZHNQFAWFQoHffvuNLtKVlZUIDQ1FRkYG0tPTcf/99/fr8VMmk6GyspJ+fOzPwAER6JM+LnmsJsWA2Y82Ra/X08WhL3MaZyOVSo1i74m0i9mP7u7u7jWh56iZuV6vR21tLSQSictGyy31cb28vKBSqRASEoKEhATWzgMcybUzlRKSZOf+6L11Oh0OHjyIzz77DAcOHKAnW12NOW3xmjVrEBISgnXr1iE3NxcdHR3u1Bb3B64g2wpxNysoKKCLNCly6enpyMjIoHuTzCLd3d2N6upqdHd399I6O4JaraYLG1MNwTxok0gkqKmpocdw2dLXMjXUfbUnTAubVCql+5727NisxSi5Eq1Wi6qqKiiVSoSHh9PvyVWDLEyIjtqZuXYGg6HXTtpU7+3v7w8vLy+Ul5dj5cqV+MMf/oBXXnmFtSlDgulBXVJSEs6ePYvhw4ejqakJU6dORUVFBatrshOuIDuCXq9HRUUF8vPzkZ+fj0uXLkGr1WLcuHFISUlBaWkphEIhnnzySYSGhrpUScB8FG1ra0NbWxt4PB5CQkIQHBzskn60uTWQw8JRo0bZraG2NvzBvOEw34u9MUqO0lfSsysGWQjkJqBWqx1WbtgC8zBXJpPh9ddfx6VLlyCXy7F48WLMmzcPYrGYdUmdaUEOCgpCZ2cngJ6vf3BwMP3rAQ5XkJ2NSqXCjh07cPjwYSQkJKCzsxMBAQH0LlosFrts58aUsZHduLkRakf70eYg4+eu8rxgDn+QIRYej4eAgABotVooFApWDfIB+5Oe7R1kYcLMtWNLNsikrKwMK1aswOTJk/H444+jtLQURUVFbnFps1aQASA4OBgdHR2srslOuILsCg4dOoR58+YhNDQUFEWhvb0dBQUFyM/PR0FBAerr6xETEwOxWIz09HSkp6fT0jt76I+ul/SjmSPUtvajzaHRaOhdGpsJGkCPMxpRMZDeLfH6Je/HGXaYpjCz9JyV9GxtkIXpP6LRaGzKtXMVOp0O+/btw1dffYWDBw9CLBaz+vrm4FoW1hn0BbkvDAYDampq6FZHUVERlEolxowZg4yMDGRkZGDcuHE2FUZnuLFZ6kczC5vpdQ0GAz1w4Eh7wh6YNwGRSGSkGGGOg5uTrPX3hmMKUTGwkfRs6j9CvjfDhg1DRESESwdZzHH9+nWsWLECDz30EDZt2sT62LMlTAvy6tWrMWzYMPpQTyKR4I033nDzKm2CK8gDBY1GgytXrtBF+urVq/D29kZqaipdpIVCIf0Yq1QqUV1d7RIZW19+HR4eHmhoaMCwYcNYTZRgGhD15yZgTrImEAiMJGt99T1Jhh/bSc+Aca5dbGys0WGbswdZzKHVarF371588803OHjwIDIyMpx27b7Ys2cP3n33XfB4PKSkpODIkSNG5wPmtMWPPfYYFixYQBtVnThxwilPMSzAFeSBCkVRkMlkKCwspFsdxKvZy8sLCoUCb731FuLj41nZIRkMBkgkElRXV0OtVoPP59Njx87uR5uDxDcNGTIE8fHxDvWorY2DM43+yY2mtbUVN27c6NOs3tnYmmvHHGSRSqVG1p79GWQxR2lpKVauXIkZM2Zg48aNrO6KGxsbMWnSJFy/fh0CgQALFizAo48+iiVLlrC2BpbhCvLdxK+//opnn30W6enpCA0NRVFRESQSCRITE+ld9IQJE5xeGJntifj4eISFhYHH4zm9H20OZoySK+KMCKYKAqLF1el08Pb2hlAoRHBwMGsyOkdz7fozyGIOrVaL3bt34/Tp03jrrbeQlpZm8e+6isbGRmRmZuLy5csIDAzEY489Rt8c7lG4gnw3UV9fD29vbyPbRJ1Oh7KyMlobfenSJVAUhfHjx9NFOikpye4dJRm1JpNffRUGYh9Jdp9qtbrPfrQ5mHIyd+xMiXyPGLczD9qY/WhX3PyINefo0aOddgOyxZBIIBDAz88PV69excqVK/HII49gw4YNrB8cMtm3bx82btwIgUCAGTNmuNOrmA24gnyvQXSvv/32GwoKClBQUICKigoEBwcbSe/6SoggXsE6nQ5JSUl296hN+9Fk52ktYkqlUtFyMntjlOylr6Rn5lMBScxwVqp2Z2cnKioq6JguV+/GTceot2zZgpKSEigUCmRlZWHOnDnIzMxkXVdM6OjowLx58/Dpp58iKCgIf/7znzF//nx3+hW7Gq4gDwbIbpMcGBYWFqKpqQlxcXG0oVJqaioCAwNpWVVXVxfdnnA21iKmNBoNlEolRCIRqwcxjiQ9WxsHJztpazcVa7l2bHH58mXk5OTg0UcfxZw5c3D58mUUFha6POfOGp999hlOnz6N9957DwDw4YcfIi8vDwcPHnTLeliAK8iDFYPBgKqqKuTl5aGgoADFxcVoa2uDRqPBrFmz8Ne//hVjx45lbXfa2tqKiooK2rbTFf1oSzg76bk/4+D25No5E7VajR07duDnn3/GoUOHMG7cOFZf3xr5+fnIzs5GYWEhBAIBlixZgoyMDKxYscLdS3MVXEHm6GHt2rUoKyvDkiVLUF9fj8LCQpSWlsLPzw9paWl0P9qcg5gjWItRclY/2hIajQYVFRUwGAwuT3om7QGm3pvkGkZGRmLYsGEICAhgTUIIACUlJcjJycFjjz2GNWvWuK01YY3Nmzfj008/BZ/PR2pqKt59990Bo392AVxB5uihra2t19gxRVHo6OhAYWEhfWhYV1eHqKgoukCnp6cjJCSk3zs75sGZUCi0qTViSa5mzePC0nWInjk+Pp7VCCdmrl1cXBz8/Px6jYObjlA7e9esVquxfft2/PLLL3j77beRkpLi1Ov3RWdnJ5YuXYrS0lLweDy8//77eOCBB1hdwwCFK8gc/YN4/TL70WRYgvSjx40bZ9XohthyBgcHmz046+96+uPXQTySAwICHNYz9xdbcu2I0T95P0qlkh4HJ+/JkXHw4uJirFq1CvPmzcNLL73kll1xVlYWJk+ejKVLl0Kj0UClUrHqGT2A4Qoyh+NotVqUlpbS/egrV67A09PTyOA/ISEBEokEpaWlCAwMdGlqiCV9tMFggEajQWJioksOKy3haK4dM2ZKKpXalWDS3d2Nbdu24eLFizh06BCSk5MdeUt2I5VKMWHCBNTU1LgzTHSgwhVkezl9+jRycnKg1+uxdOlSrFu3zt1LGjBQFAW5XE4b/BcUFKCoqAg6nQ6zZs3C9OnTIRaLnZIvZwsdHR0oKytDYGAgfHx8IJfLnd6PtoRSqaRfOz4+3mk9Yqb/CHMcnPl+yO63qKgI//jHP7Bw4UK88MILrD4VmFJSUoJly5ZhzJgxuHz5MtLT07Fv3z5WTakGMFxBtge9Xo/ExET88MMPiIqKglgsxieffIIxY8a4e2kDkpycHGg0GixfvhyVlZV0P7q1tRUJCQm0411aWhr8/f2dVqStJT07qx9tCWaMk0gkcklqCRNmyKlUKkV7ezuef/55BAQEoKOjA1u2bMHjjz/u9sJXVFSEzMxMnD9/HhMnTkROTg4CAwOxdetWt65rgMAVZHu4ePEiXn75ZfznP/8BAGzbtg0AsH79encua8BCdLmm6PV6lJeX014dxcXF0Ov1GDduHD3EMmbMmH7v6OxNejb1XGb2o/szmddXrh0bkADfadOmITExEcXFxVAoFPjwww9ZXwuT5uZmZGZmoq6uDgDwyy+/IDc3F998841b1zVAsKkgu+/5ZoDS2NiI6Oho+tdRUVHIz89344oGNpb6m56enkhOTkZycjKys7MB9EzpFRcXo6CgAHv37qUf95lThpGRkRaLHDPpOSMjo1+HVsziGxUVBcC4H11dXQ2lUmlRH83MtRszZoxbBiq6urrw6quvori4GMeOHYNIJGJ9Dda47777EB0djYqKCiQlJeHMmTPck2U/4QoyB2v4+flh0qRJdHQ8RVFoa2ujDf6PHj2KhoYGxMbGGknvfH198f333yMiIsKpSc98Ph8hISFGU4NMfXRDQwPtfqdSqRAREYHx48e7Rb2Ql5eHl156CU8++SR27tzJqqa5Pxw4cACLFi2CRqPBqFGjcOTIEXcv6a6CK8gmREZGor6+nv51Q0MDIiMjHb5ufX09Fi9ejJaWFvB4PCxbtgw5OTkOX/duhsfjISwsDLNmzcKsWbMA9LQWqqurkZ+fjx9++AEbNmxAc3Mz0tPTMWPGDHh6eiIlJcVlAwQ+Pj4ICwtDWFgY3afu6upCXFwcurq6UFJS4tR+dF+oVCps3boVJSUlOH78OBITE13yOpbQ6/XIyMhAZGQkTp061effnzBhAoqKilhY2b0JV5BNEIvFqKqqQm1tLSIjI3H8+HF8/PHHDl+Xz+dj165dSEtLg1wuR3p6OqZPn8490png4eGBhIQEJCQkIDg4GOXl5Th+/DhUKhXy8/PxzjvvoLS0FD4+PkYG//Hx8U4titZy7Zj96IaGBrv70X1x4cIFrF69GllZWdi9e7dbdsX79u3D6NGjIZPJWH/twQh3qGeGb7/9FqtWrYJer0d2djY2btzo9NeYM2cOli9fjunTpzv92vcKOp0Onp6evQobRVGQSqVGBv81NTUYMWIErY3OyMiwKw1crVbblWtHIpmYQx8k7YPspG0d31YqldiyZQtKS0vpQF130NDQgKysLGzcuBG7d++2aYfMYRFOZTFQqaurw5QpU+hBCg7HIQkcpEAXFhaio6Ojl8G/pUk4iqLQ1NSEmzdv2jzu3RekH0160qb66CFDhhj1oymKwvnz57F27VpkZ2fj73//u1t7xfPnz8f69eshl8uxc+dOriA7BqeyGIgoFArMmzcPe/fu5YqxE+HxeIiNjUVsbCwWLFgAoGfXeu3aNeTn5+PTTz/FunXrwOPxehn8V1VVob6+HtHR0RCLxU4brmD2owFjfXRrayuqq6uh1+tRUFAAmUyGmpoatLS04OTJk4iPj3fKGuzl1KlTCA8PR3p6Os6ePevWtQwmuB0yi2i1WsyePRszZ87ECy+84PTr9/cAZrBBDP6Liopog/8LFy7Aw8MDf/rTnzB58mSIxWIMHz6ctdFfvV6P48eP44MPPgDQ41LH5/Oxf/9+iMViVtZgjvXr1+Ojjz4Cn8+n7Ubnzp2Lo0ePum1Ndzlcy2IgQVEUsrKyEBISgr1797rkNXbv3o2ioiLIZDKuINvAU089hZiYGPztb3/D5cuXaUOl5uZmjBo1ysjgf8iQIU4v0gqFAps2bcKNGzfwzjvvIC4ujv59Dw8Pt5jZm+Ps2bNcy8JxuII8kPj1118xefJkpKSk0GqA119/HY8++qhTrs8dwPQftVptVj5nMBjoMXAyZajRaDB27Fi6SCcnJ9utR6YoCufOncO6devw3HPPYdmyZW6Z+LMVriA7Ba4gDya4AxjX0t3djZKSEtqr49q1a/D39zcy+I+Nje2zsMrlcvzzn/9EXV0dDh8+jJEjR7LzBjjcDXeoN1jgDmBcj6+vLzIzM5GZmQmgZ5crkUhog/8TJ07g5s2biI6ONpoyDA4OBo/HA0VROHv2LDZs2IDnn38eb7/9Nuu7Ym44aeDD7ZDvAVx9AMOlQNiGwWBAXV2dkS2pXC5HYmIi7ty5A4FAgMOHDyMmJsYt62tqakJTU5PRcNIXX3zBDSexA9eyGIy4ot/HpUDYj1arxZUrV/D1119j06ZNA6pXzA0nsQrXsuBwHKlUinPnztGyLG9vb9bSqu8FvLy8aE/ogURdXR0uXbqEiRMnunspHAwGzu2awylMnTrVqbvj2tpahIWF4emnn0ZqaiqWLl0KpVLptOtzsA83nDRw4Qoyh1V0Oh2Ki4vx3HPP4dKlS/D390dubq67l8VhJ1qtFvPmzcOiRYswd+5cdy+HwwSuIHNYJSoqClFRUfSj7fz581FcXOy06+/ZswfJyckYO3YsnnjiCXR3dzvt2hzGUBSFZ555BqNHj3bJpCiH43AFmcMqzBQIAE5NgWhsbMT+/ftRVFSE0tJSeoyYwzWcP38eH330EX766SdMmDABEyZMwLfffuvuZXEw4A71OPrElSkQOp0OXV1d8PLygkqlwogRI5x27Xud/qajT5o0Cf1UVXGwDCd743Ar+/btw8aNGyEQCDBjxgwcO3bM3Uu6K+DS0e86bJK9cS0LDrfR0dGBL7/8ErW1tbh9+zaUSiXnJmYjBQUFEAqFGDVqFLy9vfGXv/wFX375pbuXxeEgXEHmcBs//vgj4uLiEBYWBi8vL8ydOxcXLlxw6JrZ2dkIDw/H2LFj6d+TSCSYPn06EhISMH36dHR0dDi6dLdjLh29sbHRjSvicAZcQeZwGzExMcjLy4NKpQJFUThz5gxGjx7t0DWXLFmC06dPG/1ebm4upk2bhqqqKkybNo2T7XEMWLiCzOE2Jk6ciPnz5yMtLQ0pKSkwGAxYtmyZQ9ecMmUKQkJCjH7vyy+/RFZWFoCeMfAvvvjCodcYCLgqHZ3DvXCHehz3HHV1dZg9ezZKS0sBAEFBQejs7ATQo8UNDg6mf323otPpkJiYiDNnziAyMhJisRgff/wxkpOT3b00DvO4xFyIg2PAw+PxRgI4RVHU2P/7dSdFUUGMP++gKCrYTctzGjwe71EAewF4AnifoqjX3LwkDgfhdMgcg4EWHo83nKKoJh6PNxzAHXcvyBlQFPUtAG6y4x6C6yFzDAa+ApD1f/+fBYDTh3EMSLiWBcc9BY/H+wTAVAChAFoAbAbwBYATAGIA3ASwgKIoibvWyMFhCa4gc3BwcAwQuJYFBwcHxwCBK8gcHBwcAwSuIHNwcHAMELiCzMHBwTFA4AoyBwcHxwCBK8gcHBwcA4T/DzIyGXW0hr9qAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#set initial / terminal constraints\n",
+    "pD.flag = constraint_flag.END_POS | constraint_flag.INIT_POS\n",
+    "pD.degree = refDegree\n",
+    "prob = setup_control_points(pD)\n",
+    "variableBezier = prob.bezier()\n",
+    "\n",
+    "#get value of the curve first order derivative at t = 0.8\n",
+    "t08Constraint = variableBezier.derivate(0.8,1)\n",
+    "target = zeros(3) \n",
+    "\n",
+    "A, b = genCost(variableBezier, ptsTime)\n",
+    "#solve optimization problem with quadprog\n",
+    "\n",
+    "res = quadprog_solve_qp(A, b, C=t08Constraint.B(), d=target - t08Constraint.c())\n",
+    "fitBezier = evalAndPlot(variableBezier, res)\n",
+    "\n",
+    "assert norm(fitBezier.derivate(0.8,1) - target) <= 0.001\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Of course, inequality constraints can be added in a similar way\n",
+    "\n",
+    "## Constraining sub-parts of the curve\n",
+    "\n",
+    "Now suppose we want to constrain entirely parts of a curve. One common way to address this is to discretize the curve, and write as many constraints as discretization points.\n",
+    "\n",
+    "Alternatively, this can be achieved continuously by splitting the Bezier curve continuously, and putting constraints on the control points of the relevant parts.\n",
+    "\n",
+    "let's first explain how curve splitting works before writing a problem.\n",
+    "\n",
+    "Here is the code that splits our reference curve into two distinct curves at a time t = 0.6"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#returns a curve composed of the split curves, 2 in our case\n",
+    "piecewiseCurve = ref.split(array([[0.6]]).T)\n",
+    "\n",
+    "#displaying the obtained curves\n",
     "\n",
-    "#plot reference curve in blue, fitted curve in green\n",
     "fig = plt.figure()\n",
     "ax = fig.add_subplot(111, projection=\"3d\")  \n",
-    "plotBezier(ref, ax = ax, linewidth=4.) #thicker line to visualize overlap\n",
-    "plotBezier(fitBezier, ax = ax, color =\"g\", linewidth=3.) \n",
-    "plt.show()"
+    "\n",
+    "#first, plotting the complete piecewiseCurve is equivalent\n",
+    "plotBezier(piecewiseCurve, ax = ax, linewidth=10., color = \"b\")\n",
+    "plotBezier(piecewiseCurve.curve_at_index(0), ax = ax, linewidth=4., color = \"r\")\n",
+    "plotBezier(piecewiseCurve.curve_at_index(1), ax = ax, linewidth=4., color = \"orange\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can try to fit the reference curve with a curve of lesser degree"
+    "The split is achieved by the De Casteljau algorithm. The continuity at the split location is infinite.\n",
+    "Of course, the split will also work for variable Bezier curves.\n",
+    "We can exploit the convexity of Bezier curves to continuously impose constraints on a given interval of the curve.\n",
+    "If the control points of the sub curve satisfy a set of linear constraints, then the entire sub-curve satisfies the constraint.\n",
+    "\n",
+    "For instance, let us impose the z value to be negative between t = 0.4 and t= O.8"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -318,30 +700,95 @@
     }
    ],
    "source": [
-    "#defining a python method to encapsulate the fitting\n",
-    "def simplefit(degree):\n",
-    "    pD = problem_definition(dim)\n",
-    "    pD.degree = degree \n",
-    "    #generates the variable bezier curve with the parameters of problemDefinition\n",
-    "    problem = setup_control_points(pD)\n",
-    "    #for now we only care about the curve itself\n",
-    "    variableBezier = problem.bezier()\n",
-    "    allsEvals = [(variableBezier(time), pt) for (pt,time) in ptsTime]\n",
-    "    #then compute the least square form of the cost for each points\n",
-    "    allLeastSquares = [to_least_square(el.A, el.b + pt) for (el, pt) in  allsEvals]\n",
-    "    #and finally sum the costs\n",
-    "    Ab = [sum(x) for x in zip(*allLeastSquares)]\n",
-    "    res = quadprog_solve_qp(Ab[0], Ab[1])\n",
-    "    fitBezier = variableBezier.evaluate(res.reshape((-1,1)) ) \n",
-    "    fig = plt.figure()\n",
-    "    ax = fig.add_subplot(111, projection=\"3d\")  \n",
-    "    plotBezier(ref, ax = ax) #thicker line to visualize overlap\n",
-    "    plotBezier(fitBezier, ax = ax, color =\"g\") \n",
-    "    plt.show()\n",
+    "#first, split the variable curve\n",
+    "piecewiseCurve = variableBezier.split(array([[0.4, 0.8]]).T)\n",
+    "\n",
+    "constrainedCurve = piecewiseCurve.curve_at_index(1)\n",
+    "\n",
+    "#find the number of variables\n",
+    "problemSize = prob.numVariables * dim\n",
+    "#find the number of constraints, as many as waypoints\n",
+    "nConstraints = constrainedCurve.nbWaypoints\n",
+    "\n",
+    "waypoints = constrainedCurve.waypoints()\n",
+    "\n",
+    "ineqMatrix = zeros((nConstraints, problemSize))\n",
+    "ineqVector = zeros(nConstraints)\n",
+    "\n",
+    "\n",
+    "#finding the z equation of each control point\n",
+    "for i in range(nConstraints):\n",
+    "    wayPoint = constrainedCurve.waypointAtIndex(i)\n",
+    "    ineqMatrix[i,:] = wayPoint.B()[2,:]\n",
+    "    ineqVector[i] =  -wayPoint.c()[2]\n",
+    "\n",
     "    \n",
-    "simplefit(refDegree-1)"
+    "res = quadprog_solve_qp(A, b, G=ineqMatrix, h = ineqVector)\n",
+    "fitBezier = variableBezier.evaluate(res.reshape((-1,1)) ) \n",
+    "\n",
+    "\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection=\"3d\")  \n",
+    "\n",
+    "#now plotting the obtained curve, in red the concerned part\n",
+    "piecewiseFit = fitBezier.split(array([[0.4, 0.8]]).T)\n",
+    "plotBezier(piecewiseFit.curve_at_index(0), ax = ax, linewidth=4., color = \"b\")\n",
+    "plotBezier(piecewiseFit.curve_at_index(1), ax = ax, linewidth=4., color = \"r\")\n",
+    "plotBezier(piecewiseFit.curve_at_index(2), ax = ax, linewidth=4., color = \"b\")\n",
+    "\n",
+    "#plotting the plane z = 0\n",
+    "xx, yy = np.meshgrid(range(20), range(20))\n",
+    "\n",
+    "# calculate corresponding z\n",
+    "z = (0 * xx - 0 * yy )\n",
+    "\n",
+    "# plot the surface\n",
+    "ax.plot_surface(xx, yy, z, alpha=0.2)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "problemSize"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/tests/Main.cpp b/tests/Main.cpp
index 0173c3bbfb0b7b87554598d52e1c9675e86e7f2c..ca8559910c37bad5fc0cb6dd1eb615bf395a8770 100644
--- a/tests/Main.cpp
+++ b/tests/Main.cpp
@@ -1578,9 +1578,8 @@ var_pair_t setup_control_points(const std::size_t degree,
                           const constraint_linear& constraints = constraint_linear(3),
                           const double totalTime = 1.)
 {
-    problem_definition_t pDef(3);
-    pDef.curveConstraints = constraints;
-    pDef.start = initPos; pDef.end = endPos;
+    problem_definition_t pDef(constraints);
+    pDef.init_pos = initPos; pDef.end_pos = endPos;
     pDef.flag = flag;
     pDef.totalTime = totalTime;
     pDef.degree = degree;
diff --git a/tests/load_problem.h b/tests/load_problem.h
index 97ca2acbfe0197f96a5cf0fa23e4c1afe640b705..f48182c4bdb58c9e5e8fc17c40e77a7c03dfc145 100644
--- a/tests/load_problem.h
+++ b/tests/load_problem.h
@@ -94,9 +94,9 @@ problem_definition_t loadproblem(const std::string& filename)
     pDef.totalTime =degTimeFlag[1];
     pDef.flag = (constraint_flag)(degTimeFlag[2]);
     //Then startpos then empty line
-    pDef.start = readMatrix(in);
+    pDef.init_pos = readMatrix(in);
     //Then endpos then empty line
-    pDef.end = readMatrix(in);
+    pDef.end_pos = readMatrix(in);
     //Then splittimes then empty line
     pDef.splitTimes_ = readMatrix(in);
     // The inequality matrices, empty line, inequality vector as many times