diff --git a/.gitattributes b/.gitattributes
index c0ef5aa9cc1..0bb56aff483 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1387,6 +1387,7 @@ Combinatorial_map/include/CGAL/Cell_iterators.h -text
 Combinatorial_map/include/CGAL/Combinatorial_map.h -text
 Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h -text
 Combinatorial_map/include/CGAL/Combinatorial_map_constructors.h -text
+Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h -text
 Combinatorial_map/include/CGAL/Combinatorial_map_min_items.h -text
 Combinatorial_map/include/CGAL/Combinatorial_map_operations.h -text
 Combinatorial_map/include/CGAL/Dart.h -text
@@ -1394,6 +1395,7 @@ Combinatorial_map/include/CGAL/Dart_const_iterators.h -text
 Combinatorial_map/include/CGAL/Dart_iterators.h -text
 Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h -text
 Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h -text
+Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility_novariadic.h -text
 Combinatorial_map/package_info/Combinatorial_map/description.txt -text
 Combinatorial_map/package_info/Combinatorial_map/long_description.txt -text
 Combinatorial_map/package_info/Combinatorial_map/maintainer -text
diff --git a/Combinatorial_map/include/CGAL/Cell_iterators.h b/Combinatorial_map/include/CGAL/Cell_iterators.h
index 376268a52fe..bcf1b11ba0b 100644
--- a/Combinatorial_map/include/CGAL/Cell_iterators.h
+++ b/Combinatorial_map/include/CGAL/Cell_iterators.h
@@ -31,9 +31,10 @@ namespace CGAL {
    * All the cell iterators. Not commented in doxygen to avoid too much
    * classes in the documentation.
    * There are 3 classes:
-   *  - CMap_cell_iterator<Map,Ite,i,dim>
-   *  - CMap_one_dart_per_incident_cell_iterator<Map,Ite,i,dim>
-   *  - CMap_one_dart_per_cell_iterator<Map,Ite,i,dim>
+   *  - CMap_cell_iterator<Map,Ite,i,dim>: "tools" class used for the
+   *    two following iterators.
+   * * - CMap_one_dart_per_incident_cell_iterator<Map,Ite,i,dim>
+   * * - CMap_one_dart_per_cell_iterator<Map,Ite,i,dim>
    */
 
   //****************************************************************************
@@ -88,7 +89,8 @@ namespace CGAL {
       Ite(amap, adart, amap.get_new_mark()),
       mcell_mark_number(amap.get_new_mark())
     {
-      CGAL_assertion( Ite::is_basic_iterator() );
+      CGAL_static_assertion( (boost::is_same<typename Ite::Basic_iterator,
+                                             Tag_true>::value) );
       CGAL_assertion(amap.is_whole_map_unmarked(mcell_mark_number));
       
       mark_cell<Map,i,dim>(amap, adart, mcell_mark_number);
@@ -195,8 +197,9 @@ namespace CGAL {
     CMap_cell_iterator(Map& amap, Dart_handle adart):
       Ite(amap, adart),
       mmark_number(amap.get_new_mark())
-    {      
-      CGAL_assertion( Ite::is_basic_iterator() );
+    {
+      CGAL_static_assertion( (boost::is_same<typename Ite::Basic_iterator,
+                                             Tag_true>::value) );      
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, adart, mmark_number);
     }
@@ -298,7 +301,8 @@ namespace CGAL {
       Base(amap),
       mmark_number(amap.get_new_mark())
     {
-      CGAL_assertion( Base::is_basic_iterator() );
+      CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
+                                             Tag_true>::value) );
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, (*this), mmark_number);
     }
@@ -379,6 +383,9 @@ namespace CGAL {
     typedef typename Base::Dart_handle Dart_handle;
     typedef typename Base::Map Map;
 
+    typedef Tag_false Use_mark;
+    typedef Tag_false Basic_iterator;
+
     /// Main constructor.
     CMap_one_dart_per_incident_cell_iterator(Map& amap, Dart_handle adart): 
       Base(amap, adart)
@@ -402,6 +409,9 @@ namespace CGAL {
 
     typedef typename Base::Dart_handle Dart_handle;
     typedef typename Base::Map Map;
+
+    typedef Tag_false Use_mark;
+    typedef Tag_false Basic_iterator;
     
     /// Main constructor.
     CMap_one_dart_per_cell_iterator(Map& amap): Base(amap)
diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map.h b/Combinatorial_map/include/CGAL/Combinatorial_map.h
index ee296f30910..47b04386c4c 100644
--- a/Combinatorial_map/include/CGAL/Combinatorial_map.h
+++ b/Combinatorial_map/include/CGAL/Combinatorial_map.h
@@ -694,7 +694,8 @@ namespace CGAL {
     template < class Ite >
     std::ostream& display_orbits(std::ostream & aos) const
     {
-      CGAL_assertion( Ite::is_basic_iterator() );
+      CGAL_static_assertion( (boost::is_same<typename Ite::Basic_iterator,
+                                           Tag_true>::value) );
       unsigned int nb = 0;
       int amark = get_new_mark();
       for (typename Dart_range::const_iterator it1(darts().begin()),
@@ -1197,12 +1198,12 @@ namespace CGAL {
     template<unsigned int i, class Type_attr>
     void group_enabled_attribute( Dart_handle adart1, Dart_handle adart2)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
 			   "group_enabled_attribute<i> but "
 			   "i-attributes are disabled");
       CGAL_assertion(adart1 != NULL && adart2 != NULL);
       CGAL_assertion(adart1 != null_dart_handle && adart2 != null_dart_handle);
-      CGAL_assertion(i<=dimension);
 
       typename Attribute_handle<i>::type a1=adart1->template attribute<i>();
       typename Attribute_handle<i>::type a2=adart2->template attribute<i>();
@@ -1249,12 +1250,12 @@ namespace CGAL {
     template<unsigned int i, class Type_attr>
     void group_enabled_attribute_of_dart( Dart_handle dh1, Dart_handle dh2)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
 			   "group_enabled_attribute_of_dart<i> but "
 			   "i-attributes are disabled");
       CGAL_assertion( dh1!=NULL && dh2!=NULL );
       CGAL_assertion( dh1!=null_dart_handle && dh2!=null_dart_handle );
-      CGAL_assertion(i<=dimension);
 
       typename Attribute_handle<i>::type a1=dh1->template attribute<i>();
       typename Attribute_handle<i>::type a2=dh2->template attribute<i>();
@@ -1296,6 +1297,7 @@ namespace CGAL {
     template<unsigned int i, class Type_attr>
     bool degroup_enabled_attribute(Dart_handle adart1, Dart_handle adart2)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
 			   "degroup_enabled_attribute<i> but "
 			   "i-attributes are disabled");
@@ -1368,12 +1370,12 @@ namespace CGAL {
     template<unsigned int i, class Type_attr, typename Range>
     bool degroup_enabled_attribute_of_dart( Dart_handle dh1, Dart_handle dh2)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
 			   "group_enabled_attribute_of_dart<i> but "
 			   "i-attributes are disabled");
       CGAL_assertion( dh1!=NULL && dh2!=NULL );
       CGAL_assertion( dh1!=null_dart_handle && dh2!=null_dart_handle );
-      CGAL_assertion(i<=dimension);
 
       typename Attribute_handle<i>::type a1=dh1->template attribute<i>();
       typename Attribute_handle<i>::type a2=dh2->template attribute<i>();
@@ -1474,6 +1476,7 @@ namespace CGAL {
     void set_attribute_of_dart(Dart_handle adart, 
 			       typename Attribute_handle<i>::type ah)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
 			   "set_attribute_of_dart<i> but "
 			   "i-attributes are disabled");
@@ -1494,6 +1497,7 @@ namespace CGAL {
     void set_attribute(Dart_handle adart, 
 		       typename Attribute_handle<i>::type ah)
     {
+      CGAL_static_assertion(i<=dimension);
       CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
 			   "set_attribute<i> but i-attributes are disabled");
       CGAL_assertion( adart!=NULL && adart!=null_dart_handle && ah!=NULL );
@@ -1510,343 +1514,744 @@ namespace CGAL {
     }
 
 #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-    //****************************************************************************
+    //**************************************************************************
+    // Dart_of_orbit_basic_range
+    template<unsigned int ... Beta>
+    struct Dart_of_orbit_basic_range : public CMap_range
+    <Self, CMap_dart_iterator_basic_of_orbit<Self,Beta...>,
+     CMap_dart_const_iterator_basic_of_orbit<Self,Beta...> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_basic_of_orbit<Self,Beta...>,
+       CMap_dart_const_iterator_basic_of_orbit<Self,Beta...> > Base;
+    
+      Dart_of_orbit_basic_range(Self &amap, Dart_handle adart, int amark=-1):
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_orbit_basic_const_range
+    template<unsigned int ... Beta>
+    struct Dart_of_orbit_basic_const_range : public CMap_const_range
+    <Self, CMap_dart_const_iterator_basic_of_orbit<Self,Beta...> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_basic_of_orbit<Self,Beta...> > Base;
+      
+      Dart_of_orbit_basic_const_range(const Self &amap, Dart_const_handle adart,
+                                      int amark=-1):
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
     // Dart_of_orbit_range
     template<unsigned int ... Beta>
-    struct Dart_of_orbit_range {
-      typedef CMap_dart_iterator_of_orbit<Self,Beta...> iterator;
-      typedef CMap_dart_const_iterator_of_orbit<Self,Beta...> const_iterator;
-      Dart_of_orbit_range(Self &amap, Dart_handle adart) :
-	mmap(amap), mdart(adart), msize(0)
+    struct Dart_of_orbit_range : public CMap_range
+    <Self, CMap_dart_iterator_of_orbit<Self,Beta...>,
+     CMap_dart_const_iterator_of_orbit<Self,Beta...> >
+    {
+      typedef CMap_range
+    <Self, CMap_dart_iterator_of_orbit<Self,Beta...>,
+     CMap_dart_const_iterator_of_orbit<Self,Beta...> > Base;
+    
+      Dart_of_orbit_range(Self &amap, Dart_handle adart) : Base(amap,adart)
       {}
-      iterator begin() { return iterator(mmap,mdart); }
-      iterator end()   { return iterator(mmap,NULL); }
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( iterator it=begin(),itend=end(); it!=itend; ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      Self & mmap;
-      Dart_handle mdart;
-      size_type msize;
     };
-    //****************************************************************************
+    //**************************************************************************
     // Dart_of_orbit_const_range
     template<unsigned int ... Beta>
-    struct Dart_of_orbit_const_range {
-      typedef CMap_dart_const_iterator_of_orbit<Self,Beta...> const_iterator;
-      Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart) :
-	mmap(amap), mdart(adart), msize(0)
+    struct Dart_of_orbit_const_range : public CMap_const_range
+    <Self, CMap_dart_const_iterator_of_orbit<Self,Beta...> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_of_orbit<Self,Beta...> > Base;
+      
+      Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart):
+        Base(amap,adart)
       {}
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( const_iterator it=begin(),itend=end(); it!=itend; ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      const Self & mmap;
-      Dart_const_handle mdart;
-      size_type msize;
     };
-#else
-    //****************************************************************************
-    // Dart_of_orbit_range    
-    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
-	     int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
-    struct Dart_of_orbit_range {
-      typedef CMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> 
-      iterator;
-      typedef CMap_dart_const_iterator_of_orbit
-      <Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> const_iterator;
-      Dart_of_orbit_range(Self &amap, Dart_handle adart) : 
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      iterator begin() { return iterator(mmap,mdart); }
-      iterator end()   { return iterator(mmap,NULL); }
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( iterator it=begin(),itend=end(); it!=itend; ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      Self & mmap;
-      Dart_handle mdart;
-      size_type msize;
-    };
-    //****************************************************************************
-    // Dart_of_orbit_const_range    
-    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
-	     int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
-    struct Dart_of_orbit_const_range {
-      typedef CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> 
-      const_iterator;
-      Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart) : 
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( const_iterator it=begin(),itend=end(); it!=itend; ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      const Self & mmap;
-      Dart_const_handle mdart;
-      size_type msize;
-    };
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-    //****************************************************************************
-    // Dart_of_cell_range
-    template<unsigned int i,int dim=Self::dimension>
-    struct Dart_of_cell_range {
-      typedef CMap_dart_iterator_of_cell<Self,i,dim> iterator;
-      typedef CMap_dart_const_iterator_of_cell<Self,i,dim> const_iterator;
-      Dart_of_cell_range(Self &amap, Dart_handle adart) : 
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      iterator begin() { return iterator(mmap,mdart); }
-      iterator end()   { return iterator(mmap,NULL); }
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      Self & mmap;
-      Dart_handle mdart;
-      size_type msize;
-    };
-    //****************************************************************************
-    // Dart_of_cell_const_range
-    template<unsigned int i,int dim=Self::dimension>
-    struct Dart_of_cell_const_range {
-      typedef CMap_dart_const_iterator_of_cell<Self,i,dim> const_iterator;
-      Dart_of_cell_const_range(const Self &amap, Dart_const_handle adart) : 
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( const_iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      const Self & mmap;
-      Dart_const_handle mdart;
-      size_type msize;
-    };
-    //****************************************************************************
-
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+    //**************************************************************************
     /// @return a range on all the darts of the given orbit
     template<unsigned int ... Beta>
     Dart_of_orbit_range<Beta...> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<Beta...>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template<unsigned int ... Beta>
     Dart_of_orbit_const_range<Beta...> 
     darts_of_orbit(Dart_const_handle adart) const
     { return Dart_of_orbit_const_range<Beta...>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int ... Beta>
+    Dart_of_orbit_basic_range<Beta...> darts_of_orbit_basic(Dart_handle adart,
+                                                            int amark=-1)
+    { return Dart_of_orbit_basic_range<Beta...>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int ... Beta>
+    Dart_of_orbit_basic_const_range<Beta...> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<Beta...>(*this,adart,amark); }
+    //**************************************************************************
 #else
+    //**************************************************************************
+    // Dart_of_orbit_basic_range    
+    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+             int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
+    struct Dart_of_orbit_basic_range: public CMap_range
+    <Self, CMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
+     CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
+       CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+      Base;
+      
+      Dart_of_orbit_basic_range(Self &amap, Dart_handle adart, int amark=-1): 
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_orbit_basic_const_range    
+    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+             int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
+    struct Dart_of_orbit_basic_const_range: public CMap_const_range
+    <Self,
+     CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+    {
+      typedef CMap_const_range <Self,
+       CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+      Base;
+      
+      Dart_of_orbit_basic_const_range(const Self &amap, Dart_const_handle adart,
+                                      int amark=-1): 
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_orbit_range    
+    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+	     int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
+    struct Dart_of_orbit_range: public CMap_range
+    <Self, CMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
+     CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
+       CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+      Base;
+    
+      Dart_of_orbit_range(Self &amap, Dart_handle adart): 
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_orbit_const_range    
+    template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+	     int B6=-1,int B7=-1,int B8=-1,int B9=-1>    
+    struct Dart_of_orbit_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
+      Base;
+      
+      Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart): 
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
     /// @return a range on all the darts of the given orbit
     Dart_of_orbit_range<> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<>(*this,adart); }
-    Dart_of_orbit_const_range<> darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<>(*this,adart); }
-    
+    //--------------------------------------------------------------------------
     template <unsigned int B1>
     Dart_of_orbit_range<B1> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1>(*this,adart); }
-    template <unsigned int B1>
-    Dart_of_orbit_const_range<B1> darts_of_orbit(Dart_const_handle 
-						 adart) const
-    { return Dart_of_orbit_const_range<B1>(*this,adart); }
-    
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2>
     Dart_of_orbit_range<B1,B2> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2>(*this,adart); }
-    template <unsigned int B1,unsigned int B2>
-    Dart_of_orbit_const_range<B1,B2> darts_of_orbit(Dart_const_handle 
-						    adart) const
-    { return Dart_of_orbit_const_range<B1,B2>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3>
     Dart_of_orbit_range<B1,B2,B3> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3>(*this,adart); }
-    template <unsigned int B1,unsigned int B2,unsigned int B3>
-    Dart_of_orbit_range<B1,B2,B3> darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_range<B1,B2,B3>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
     Dart_of_orbit_range<B1,B2,B3,B4> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4>(*this,adart); }
-    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
-    Dart_of_orbit_const_range<B1,B2,B3,B4> 
-    darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<B1,B2,B3,B4>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5>
+              unsigned int B5>
     Dart_of_orbit_range<B1,B2,B3,B4,B5> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4,B5>(*this,adart); }
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5>
-    Dart_of_orbit_const_range<B1,B2,B3,B4,B5> 
-    darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5>(*this,adart); }
-
-    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6>
+              unsigned int B5,unsigned int B6>
     Dart_of_orbit_range<B1,B2,B3,B4,B5,B6> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
-    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6>
-    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6> 
-    darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
 	      unsigned int B5,unsigned int B6,unsigned int B7>
     Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6,unsigned int B7>
-    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7> 
-    darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
-
-    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
     Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
     (Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
-    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8> 
-    darts_of_orbit(Dart_const_handle adart) const
-    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
-
-    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
-	      unsigned int B9>
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
+              unsigned int B9>
     Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9> 
     darts_of_orbit(Dart_handle adart)
     { return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>(*this,adart); }
+    //--------------------------------------------------------------------------
+    // Const versions.
+    Dart_of_orbit_const_range<> darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1>
+    Dart_of_orbit_const_range<B1> darts_of_orbit(Dart_const_handle 
+                                                 adart) const
+    { return Dart_of_orbit_const_range<B1>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2>
+    Dart_of_orbit_const_range<B1,B2> darts_of_orbit(Dart_const_handle 
+                                                    adart) const
+    { return Dart_of_orbit_const_range<B1,B2>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3>
+    Dart_of_orbit_const_range<B1,B2,B3> darts_of_orbit
+    (Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
+    Dart_of_orbit_const_range<B1,B2,B3,B4> 
+    darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3,B4>(*this,adart); }
+    //--------------------------------------------------------------------------
     template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
-	      unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
-	      unsigned int B9>
+              unsigned int B5>
+    Dart_of_orbit_const_range<B1,B2,B3,B4,B5> 
+    darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6>
+    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6> 
+    darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7>
+    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7> 
+    darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
+    Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8> 
+    darts_of_orbit(Dart_const_handle adart) const
+    { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
+              unsigned int B9>
     Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9> 
     darts_of_orbit(Dart_const_handle adart) const
     { return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
-	(*this,adart); }
+        (*this,adart); }
+    //--------------------------------------------------------------------------
+		// Basic versions
+    Dart_of_orbit_basic_range<> darts_of_orbit_basic(Dart_handle adart,
+                                                     int amark=-1)
+    { return Dart_of_orbit_basic_range<>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    Dart_of_orbit_basic_const_range<> darts_of_orbit_basic
+    (Dart_const_handle adart,int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1>
+    Dart_of_orbit_basic_range<B1> darts_of_orbit_basic(Dart_handle adart,
+                                                       int amark=-1)
+    { return Dart_of_orbit_basic_range<B1>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1>
+    Dart_of_orbit_basic_const_range<B1> darts_of_orbit_basic
+    (Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2>
+    Dart_of_orbit_basic_range<B1,B2> darts_of_orbit_basic(Dart_handle adart,
+                                                          int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2>
+    Dart_of_orbit_basic_const_range<B1,B2> darts_of_orbit_basic
+    (Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3>
+    Dart_of_orbit_basic_range<B1,B2,B3> darts_of_orbit_basic(Dart_handle adart,
+                                                             int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3>
+    Dart_of_orbit_basic_const_range<B1,B2,B3> darts_of_orbit_basic
+    (Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4> darts_of_orbit_basic
+    (Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4,B5> darts_of_orbit_basic
+    (Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6> darts_of_orbit_basic
+    (Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit_basic
+    (Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
+    (Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+	      unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
+              unsigned int B9>
+    Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9> 
+    darts_of_orbit_basic(Dart_handle adart, int amark=-1)
+    { return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------    
+    template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
+              unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
+              unsigned int B9>
+    Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9> 
+    darts_of_orbit_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
+        (*this,adart,amark); }
+    //**************************************************************************
 #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
+    //**************************************************************************
+    // Dart_of_cell_basic_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_cell_basic_range: public CMap_range
+    <Self, CMap_dart_iterator_basic_of_cell<Self,i,dim>,
+     CMap_dart_const_iterator_basic_of_cell<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_basic_of_cell<Self,i,dim>,
+       CMap_dart_const_iterator_basic_of_cell<Self,i,dim> > Base;
+    
+      Dart_of_cell_basic_range(Self &amap, Dart_handle adart, int amark=-1) : 
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_cell_basic_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_cell_basic_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_basic_of_cell<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_basic_of_cell<Self,i,dim> > Base;
+      
+      Dart_of_cell_basic_const_range(const Self &amap, Dart_const_handle adart,
+                                     int amark=-1) : 
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_cell_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_cell_range: public CMap_range
+    <Self,CMap_dart_iterator_of_cell<Self,i,dim>,
+     CMap_dart_const_iterator_of_cell<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self,CMap_dart_iterator_of_cell<Self,i,dim>,
+       CMap_dart_const_iterator_of_cell<Self,i,dim> > Base;
+    
+      Dart_of_cell_range(Self &amap, Dart_handle adart) : 
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_cell_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_cell_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_of_cell<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_of_cell<Self,i,dim> > Base;
+      
+      Dart_of_cell_const_range(const Self &amap, Dart_const_handle adart) : 
+        Base(amap, adart)
+      {}
+    };
+    //--------------------------------------------------------------------------
     /// @return a range on all the darts of the given i-cell
     template<unsigned int i, int dim>
+    Dart_of_cell_basic_range<i,dim> darts_of_cell_basic(Dart_handle adart,
+                                                        int amark=-1)
+    { return Dart_of_cell_basic_range<i,dim>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i, int dim>
+    Dart_of_cell_basic_const_range<i,dim> darts_of_cell_basic
+    (Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_cell_basic_const_range<i,dim>(*this,adart,amark); }
+    //--------------------------------------------------------------------------    
+    template<unsigned int i>
+    Dart_of_cell_basic_range<i,Self::dimension>
+    darts_of_cell_basic(Dart_handle adart, int amark=-1)
+    { return darts_of_cell_basic<i,Self::dimension>(adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_cell_basic_const_range<i,Self::dimension> 
+    darts_of_cell_basic(Dart_const_handle adart, int amark=-1) const
+    { return darts_of_cell_basic<i,Self::dimension>(adart,amark); }    
+    //--------------------------------------------------------------------------
+    template<unsigned int i, int dim>
     Dart_of_cell_range<i,dim> darts_of_cell(Dart_handle adart)
     { return Dart_of_cell_range<i,dim>(*this,adart); }    
-    
+    //--------------------------------------------------------------------------    
     template<unsigned int i, int dim>
     Dart_of_cell_const_range<i,dim> darts_of_cell(Dart_const_handle adart) const
     { return Dart_of_cell_const_range<i,dim>(*this,adart); }
-    
+    //--------------------------------------------------------------------------    
     template<unsigned int i>
     Dart_of_cell_range<i,Self::dimension> darts_of_cell(Dart_handle adart)
     { return darts_of_cell<i,Self::dimension>(adart); }    
-
+    //--------------------------------------------------------------------------
     template<unsigned int i>
     Dart_of_cell_const_range<i,Self::dimension> 
     darts_of_cell(Dart_const_handle adart) const
-    { return darts_of_cell<i,Self::dimension>(adart); }    
-
+    { return darts_of_cell<i,Self::dimension>(adart); }
+    //**************************************************************************
+    // Dart_of_involution_basic_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_basic_range: public CMap_range
+    <Self, CMap_dart_iterator_basic_of_involution<Self,i,dim>,
+     CMap_dart_const_iterator_basic_of_involution<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_basic_of_involution<Self,i,dim>,
+       CMap_dart_const_iterator_basic_of_involution<Self,i,dim> > Base;
+    
+      Dart_of_involution_basic_range(Self &amap, Dart_handle adart,
+                                     int amark=-1):
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_involution_basic_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_basic_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_basic_of_involution<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_basic_of_involution<Self,i,dim> > Base;
+      
+      Dart_of_involution_basic_const_range(const Self &amap,
+                                           Dart_const_handle adart,
+                                           int amark=-1) : 
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    template<unsigned int i,int dim>
+    Dart_of_involution_basic_range<i,dim>
+    darts_of_involution_basic(Dart_handle adart, int amark=-1)
+    { return Dart_of_involution_basic_range<i,dim>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i,int dim>
+    Dart_of_involution_basic_const_range<i,dim>
+    darts_of_involution_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_involution_basic_const_range<i,dim>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_basic_range<i,Self::dimension>
+    darts_of_involution_basic(Dart_handle adart, int amark=-1)
+    { return Dart_of_involution_basic_range<i,Self::dimension>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_basic_const_range<i,Self::dimension>
+    darts_of_involution_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_involution_basic_const_range<i,Self::dimension>
+        (*this,adart,amark); }
+    //**************************************************************************
+    // Dart_of_involution_inv_basic_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_inv_basic_range: public CMap_range
+    <Self, CMap_dart_iterator_basic_of_involution_inv<Self,i,dim>,
+     CMap_dart_const_iterator_basic_of_involution_inv<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_basic_of_involution_inv<Self,i,dim>,
+       CMap_dart_const_iterator_basic_of_involution_inv<Self,i,dim> > Base;
+    
+      Dart_of_involution_inv_basic_range(Self &amap, Dart_handle adart,
+                                         int amark=-1):
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_involution_inv_basic_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_inv_basic_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_basic_of_involution_inv<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_basic_of_involution_inv<Self,i,dim> >
+      Base;
+      
+      Dart_of_involution_inv_basic_const_range(const Self &amap,
+                                               Dart_const_handle adart,
+                                               int amark=-1) : 
+        Base(amap, adart, amark)
+      {}
+    };
+    //**************************************************************************
+    template<unsigned int i,int dim>
+    Dart_of_involution_inv_basic_range<i,dim>
+    darts_of_involution_inv_basic(Dart_handle adart, int amark=-1)
+    { return Dart_of_involution_inv_basic_range<i,dim>(*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i,int dim>
+    Dart_of_involution_inv_basic_const_range<i,dim>
+    darts_of_involution_inv_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_involution_inv_basic_const_range<i,dim>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_inv_basic_range<i,Self::dimension>
+    darts_of_involution_inv_basic(Dart_handle adart, int amark=-1)
+    { return Dart_of_involution_inv_basic_range<i,Self::dimension>
+        (*this,adart,amark); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_inv_basic_const_range<i,Self::dimension>
+    darts_of_involution_inv_basic(Dart_const_handle adart, int amark=-1) const
+    { return Dart_of_involution_inv_basic_const_range<i,Self::dimension>
+        (*this,adart,amark); }    
+    //**************************************************************************
+    // Dart_of_involution_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_range: public CMap_range
+    <Self, CMap_dart_iterator_of_involution<Self,i,dim>,
+     CMap_dart_const_iterator_of_involution<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_of_involution<Self,i,dim>,
+       CMap_dart_const_iterator_of_involution<Self,i,dim> > Base;
+    
+      Dart_of_involution_range(Self &amap, Dart_handle adart) :
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_involution_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_of_involution<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_of_involution<Self,i,dim> > Base;
+      
+      Dart_of_involution_const_range(const Self &amap, Dart_const_handle adart):
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    template<unsigned int i,int dim>
+    Dart_of_involution_range<i,dim>
+    darts_of_involution(Dart_handle adart)
+    { return Dart_of_involution_range<i,dim>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i,int dim>
+    Dart_of_involution_const_range<i,dim>
+    darts_of_involution(Dart_const_handle adart) const
+    { return Dart_of_involution_const_range<i,dim>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_range<i,Self::dimension>
+    darts_of_involution(Dart_handle adart)
+    { return Dart_of_involution_range<i,Self::dimension>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_const_range<i,Self::dimension>
+    darts_of_involution(Dart_const_handle adart) const
+    { return Dart_of_involution_const_range<i,Self::dimension>(*this,adart); }
+    //**************************************************************************
+    // Dart_of_involution_inv_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_inv_range: public CMap_range
+    <Self, CMap_dart_iterator_of_involution_inv<Self,i,dim>,
+     CMap_dart_const_iterator_of_involution_inv<Self,i,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_dart_iterator_of_involution_inv<Self,i,dim>,
+       CMap_dart_const_iterator_of_involution_inv<Self,i,dim> > Base;
+    
+      Dart_of_involution_inv_range(Self &amap, Dart_handle adart) :
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    // Dart_of_involution_inv_const_range
+    template<unsigned int i,int dim=Self::dimension>
+    struct Dart_of_involution_inv_const_range: public CMap_const_range
+    <Self, CMap_dart_const_iterator_of_involution_inv<Self,i,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_dart_const_iterator_of_involution_inv<Self,i,dim> > Base;
+      
+      Dart_of_involution_inv_const_range(const Self &amap,
+                                         Dart_const_handle adart):
+        Base(amap, adart)
+      {}
+    };
+    //**************************************************************************
+    template<unsigned int i,int dim>
+    Dart_of_involution_inv_range<i,dim>
+    darts_of_involution_inv(Dart_handle adart)
+    { return Dart_of_involution_inv_range<i,dim>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i,int dim>
+    Dart_of_involution_inv_const_range<i,dim>
+    darts_of_involution_inv(Dart_const_handle adart) const
+    { return Dart_of_involution_inv_const_range<i,dim>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_inv_range<i,Self::dimension>
+    darts_of_involution_inv(Dart_handle adart)
+    { return Dart_of_involution_inv_range<i,Self::dimension>(*this,adart); }
+    //--------------------------------------------------------------------------
+    template<unsigned int i>
+    Dart_of_involution_inv_const_range<i,Self::dimension>
+    darts_of_involution_inv(Dart_const_handle adart) const
+    { return Dart_of_involution_inv_const_range<i,Self::dimension>
+        (*this,adart); }
+    //**************************************************************************
+    // Dart_basic_range
+    struct Dart_basic_range {
+      typedef CMap_dart_iterator_basic_of_all<Self> iterator;
+      typedef CMap_dart_const_iterator_basic_of_all<Self> const_iterator;
+      Dart_basic_range(Self &amap) : mmap(amap)
+      {}
+      iterator begin() { return iterator(mmap); }
+      iterator end()   { return iterator(mmap,NULL); }
+      const_iterator begin() const { return const_iterator(mmap); }
+      const_iterator end() const   { return const_iterator(mmap,NULL); }
+      size_type size()
+      { return mmap.number_of_darts(); }
+      bool empty() const
+      { return mmap.is_empty(); }
+    private:
+      Self & mmap;
+    };
+    //**************************************************************************
+    // Dart_basic_const_range
+    struct Dart_basic_const_range {
+      typedef CMap_dart_const_iterator_basic_of_all<Self> const_iterator;
+      Dart_basic_const_range(Self &amap) : mmap(amap)
+      {}
+      const_iterator begin() const { return const_iterator(mmap); }
+      const_iterator end() const   { return const_iterator(mmap,NULL); }
+      size_type size() const
+      { return mmap.number_of_darts(); }
+      bool empty() const
+      { return mmap.is_empty(); }
+    private:
+      const Self & mmap;
+    };
+    //**************************************************************************
+    Dart_basic_range darts_basic()
+    { return Dart_basic_range(*this); }
+    //--------------------------------------------------------------------------
+    Dart_basic_const_range darts_basic() const
+    { return Dart_basic_const_range(*this); }
     //**************************************************************************
     // One_dart_per_incident_cell_range
     template<unsigned int i,unsigned int j,int dim=Self::dimension>
-    struct One_dart_per_incident_cell_range {
-      typedef CMap_one_dart_per_incident_cell_iterator<Self,i,j,dim> iterator;
-      typedef CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> 
-      const_iterator;
-      One_dart_per_incident_cell_range(Self &amap, Dart_handle adart) : 
-	mmap(amap), mdart(adart),msize(0)
+    struct One_dart_per_incident_cell_range: public CMap_range
+    <Self, CMap_one_dart_per_incident_cell_iterator<Self,i,j,dim>,
+     CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> >
+    {
+      typedef CMap_range
+      <Self, CMap_one_dart_per_incident_cell_iterator<Self,i,j,dim>,
+       CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> > Base;
+    
+      One_dart_per_incident_cell_range(Self &amap, Dart_handle adart): 
+        Base(amap, adart)
       {}
-      iterator begin() { return iterator(mmap,mdart); }
-      iterator end()   { return iterator(mmap,NULL); }
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      Self & mmap;
-      Dart_handle mdart;
-      size_type msize;
     };
     //**************************************************************************
     // One_dart_per_incident_cell_const_range
     template<unsigned int i,unsigned int j,int dim=Self::dimension>
-    struct One_dart_per_incident_cell_const_range {
-      typedef CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> 
-      const_iterator;
+    struct One_dart_per_incident_cell_const_range: public CMap_const_range
+    <Self, CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> >
+    {
+      typedef CMap_const_range
+      <Self, CMap_one_dart_per_incident_cell_const_iterator<Self,i,j,dim> >
+      Base;
+      
       One_dart_per_incident_cell_const_range(const Self &amap, 
-					     Dart_const_handle adart) : 
-	mmap(amap), mdart(adart), msize(0)
+                                             Dart_const_handle adart) : 
+        Base(amap, adart)
       {}
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for ( const_iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mdart==NULL; }
-    private:
-      const Self & mmap;
-      Dart_const_handle mdart;
-      size_type msize;
     };
     //**************************************************************************
     // One_dart_per_cell_range
@@ -1862,10 +2267,10 @@ namespace CGAL {
       const_iterator end() const   { return const_iterator(mmap,NULL); }
       size_type size()
       {
-	if (msize==0)
-	  for ( iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
+        if (msize==0)
+          for ( const_iterator it=begin(); it!=end(); ++it)
+            ++msize;
+        return msize;
       }
       bool empty() const
       { return mmap.is_empty(); }
@@ -1884,10 +2289,10 @@ namespace CGAL {
       const_iterator end() const   { return const_iterator(mmap,NULL); }
       size_type size()
       {
-	if (msize==0)
-	  for ( const_iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
+        if (msize==0)
+          for ( const_iterator it=begin(); it!=end(); ++it)
+            ++msize;
+        return msize;
       }
       bool empty() const
       { return mmap.is_empty(); }
@@ -1896,95 +2301,44 @@ namespace CGAL {
       size_type msize;
     };
     //**************************************************************************
-    // Dart_of_involution_range
-    template<unsigned int i,int dim=Self::dimension>
-    struct Dart_of_involution_range {
-      typedef CMap_dart_iterator_of_involution<Self,i,dim> iterator;
-      typedef CMap_dart_const_iterator_of_involution<Self,i,dim> const_iterator;
-      Dart_of_involution_range(Self &amap, Dart_handle adart) :
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      iterator begin()             { return iterator(mmap,mdart); }
-      iterator end()               { return iterator(mmap,NULL); }
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for (iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mmap.is_empty(); }
-    private:
-      Self & mmap;
-      Dart_handle mdart;
-      size_type msize;
-    };
-    //**************************************************************************
-    // Dart_of_involution_const_range
-    template<unsigned int i,int dim=Self::dimension>
-    struct Dart_of_involution_const_range {
-      typedef CMap_dart_const_iterator_of_involution<Self,i,dim> const_iterator;
-      Dart_of_involution_const_range(const Self &amap, Dart_const_handle adart) :
-	mmap(amap), mdart(adart), msize(0)
-      {}
-      const_iterator begin() const { return const_iterator(mmap,mdart); }
-      const_iterator end() const   { return const_iterator(mmap,NULL); }
-      size_type size()
-      {
-	if (msize==0)
-	  for (const_iterator it=begin(); it!=end(); ++it)
-	    ++msize;
-	return msize;
-      }
-      bool empty() const
-      { return mmap.is_empty(); }
-    private:
-      const Self & mmap;
-      Dart_const_handle mdart;
-      size_type msize;
-    };
-    //**************************************************************************
-    
     /// @return a range on the i-cells incindent to the given j-cell.
     template<unsigned int i, unsigned int j, int dim>
     One_dart_per_incident_cell_range<i,j,dim> 
     one_dart_per_incident_cell(Dart_handle adart)
     { return One_dart_per_incident_cell_range<i,j,dim>(*this,adart); }
-    
+    //--------------------------------------------------------------------------
     template<unsigned int i, unsigned int j, int dim>
     One_dart_per_incident_cell_const_range<i,j,dim> 
     one_dart_per_incident_cell(Dart_const_handle adart) const
     { return One_dart_per_incident_cell_const_range<i,j,dim>(*this,adart); }
-
+    //--------------------------------------------------------------------------
     template<unsigned int i, unsigned int j>
     One_dart_per_incident_cell_range<i,j,Self::dimension> 
     one_dart_per_incident_cell(Dart_handle adart)
     { return one_dart_per_incident_cell<i,j,Self::dimension>(adart); }
-
+    //--------------------------------------------------------------------------
     template<unsigned int i, unsigned int j>
     One_dart_per_incident_cell_const_range<i,j,Self::dimension> 
     one_dart_per_incident_cell(Dart_const_handle adart) const
     { return one_dart_per_incident_cell<i,j,Self::dimension>(adart); }
-
+    //--------------------------------------------------------------------------
     /// @return a range on all the i-cells
     template<unsigned int i, int dim>
     One_dart_per_cell_range<i,dim> one_dart_per_cell()
     { return One_dart_per_cell_range<i,dim>(*this); }
-    
+    //--------------------------------------------------------------------------
     template<unsigned int i, int dim>
     One_dart_per_cell_const_range<i,dim> one_dart_per_cell() const
     { return One_dart_per_cell_const_range<i,dim>(*this); }
-    
+    //--------------------------------------------------------------------------
     template<unsigned int i>
     One_dart_per_cell_range<i,Self::dimension> one_dart_per_cell()
     { return one_dart_per_cell<i,Self::dimension>(); }
-
+    //--------------------------------------------------------------------------
     template<unsigned int i>
     One_dart_per_cell_const_range<i,Self::dimension> one_dart_per_cell() const
     { return one_dart_per_cell<i,Self::dimension>(); }
+    //--------------------------------------------------------------------------
 
   public:
     /// Void dart. A dart d is i-free if beta_i(d)=null_dart_handle.
@@ -2036,7 +2390,6 @@ namespace CGAL {
   // =  mnull_dart_container.emplace( std::bitset<NB_MARKS>() );
   // Does not work on windows => segfault
   // Thus we initialize null_dart_handle in the Combinatorial_map constructor
-  // Not thread safe !
 
   template < unsigned int d_, 
 	     class Items_=Combinatorial_map_min_items<d_>,
@@ -2055,7 +2408,6 @@ namespace CGAL {
     typedef typename Base::Alloc Alloc;
   };
 
-
 } // namespace CGAL
 
 #endif // CGAL_COMBINATORIAL_MAP_H //
diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h b/Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h
index 5a5e7f36d03..8ce7e2ba315 100644
--- a/Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h
+++ b/Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h
@@ -37,7 +37,8 @@ bool belong_to_same_orbit(const Map & amap,
 			  typename Map::Dart_const_handle adart1,
 			  typename Map::Dart_const_handle adart2)
 {
-  CGAL_assertion( (!Iterator::is_basic_iterator()) );
+  CGAL_static_assertion( (boost::is_same<typename Iterator::Basic_iterator,
+                                         Tag_false>::value) );
   bool found = false;
 
   for (Iterator it(amap, adart1); !found && it.cont(); ++it)
@@ -59,7 +60,8 @@ bool is_whole_orbit_marked(const Map & amap,
 			   typename Map::Dart_const_handle adart,
 			   int amark)
 {
-  CGAL_assertion( !Iterator::is_basic_iterator() );
+  CGAL_static_assertion( (boost::is_same<typename Iterator::Basic_iterator,
+                                         Tag_false>::value) );
   bool res = true;
 
   for ( Iterator it(amap, adart); res && it.cont(); ++it )
@@ -99,7 +101,8 @@ typename Map::size_type mark_orbit(const Map & amap,
 				   typename Map::Dart_const_handle adart,
 				   unsigned int amark)
 {
-  CGAL_assertion( Iterator::is_basic_iterator() );
+  CGAL_static_assertion( (boost::is_same<typename Iterator::Basic_iterator,
+                                         Tag_true>::value) );
   CGAL_assertion( (is_whole_orbit_unmarked<Map,
 		   CMap_non_basic_iterator<Map,Iterator> >
 		   (amap, adart, amark)) );
@@ -143,7 +146,9 @@ typename Map::size_type unmark_orbit(const Map & amap,
 			  typename Map::Dart_const_handle adart1,
 			  typename Map::Dart_const_handle adart2)
 {
-  return belong_to_same_orbit<Map,CMap_dart_const_iterator_of_cell<Map,i,d> >
+  return belong_to_same_orbit<Map,
+                              typename Map::template
+                              Dart_of_cell_range<i,d>::const_iterator>
     (amap, adart1, adart2);
 }
 
@@ -167,7 +172,9 @@ bool is_whole_cell_marked(const Map & amap,
 			  typename Map::Dart_const_handle adart,
 			  unsigned int amark)
 {  
-  return is_whole_orbit_marked<Map,CMap_dart_const_iterator_of_cell<Map,i,d> >
+  return is_whole_orbit_marked<Map,
+                               typename Map::template
+                               Dart_of_cell_range<i,d>::const_iterator>
         (amap, adart, amark);
 }
 
@@ -190,7 +197,9 @@ bool is_whole_cell_unmarked(const Map & amap,
 			    typename Map::Dart_const_handle adart,
 			    unsigned int amark)
 {  
-  return is_whole_orbit_unmarked<Map,CMap_dart_const_iterator_of_cell<Map,i,d> >
+  return is_whole_orbit_unmarked<Map,
+                                 typename Map::template
+                                 Dart_of_cell_range<i,d>::iterator>
         (amap, adart, amark);
 }
 
@@ -211,9 +220,11 @@ bool is_whole_cell_unmarked(const Map & amap,
  */
 template < class Map, unsigned int i, unsigned int d >
 typename Map::size_type mark_cell(const Map & amap, 
-				  typename Map::Dart_const_handle adart,
-				  int amark)
-{ return mark_orbit<Map,CMap_dart_const_iterator_basic_of_cell<Map,i,d> >
+          typename Map::Dart_const_handle adart,
+          int amark)
+{ return mark_orbit<Map,
+                    typename Map::template
+                    Dart_of_cell_basic_range<i,d>::const_iterator>
     (amap, adart, amark); }
      
 template < class Map, unsigned int i>
@@ -231,9 +242,11 @@ typename Map::size_type mark_cell(const Map & amap,
  */
 template < class Map, unsigned int i, unsigned int d >
 typename Map::size_type unmark_cell(const Map & amap, 
-				    typename Map::Dart_handle adart,
-				    int amark)
-{ return unmark_orbit<Map,CMap_dart_const_iterator_basic_of_cell<Map,i,d> >
+            typename Map::Dart_handle adart,
+            int amark)
+{ return unmark_orbit<Map,
+                      typename Map::template
+                      Dart_of_cell_basic_range<i,d>::const_iterator>
      (amap, adart, amark);}
 
 template < class Map, unsigned int i >
@@ -258,7 +271,8 @@ typename Map::size_type degree( const Map & amap,
   int mark = amap.get_new_mark();
   int treated = amap.get_new_mark();
 
-  CMap_dart_const_iterator_basic_of_cell<Map,i> it(amap, adart, mark);
+  typename Map::template
+    Dart_of_cell_basic_range<i>::const_iterator it(amap, adart, mark);
   for ( ;it.cont(); ++it )
     {
       if (!amap.is_marked(*it, treated))
@@ -304,7 +318,8 @@ typename Map::size_type codegree(const Map & amap,
   int mark = amap.get_new_mark();
   int treated = amap.get_new_mark();
 
-  CMap_dart_const_iterator_basic_of_cell<Map,i> it(amap, adart, mark);
+  typename Map::template
+    Dart_of_cell_basic_range<i>::const_iterator it(amap, adart, mark);
   for ( ; it.cont(); ++it)
     {
       if (!amap.is_marked(*it, treated))
diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h b/Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h
new file mode 100644
index 00000000000..a678fac34f5
--- /dev/null
+++ b/Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h
@@ -0,0 +1,550 @@
+// Copyright (c) 2010-2011 CNRS and LIRIS' Establishments (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation; either version 3 of the License,
+// or (at your option) any later version.
+//
+// Licensees holding a valid commercial license may use this file in
+// accordance with the commercial license agreement provided with the software.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// $URL$
+// $Id$
+//
+// Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
+//
+#ifndef CGAL_COMBINATORIAL_MAP_ITERATORS_BASE_HH
+#define CGAL_COMBINATORIAL_MAP_ITERATORS_BASE_HH 1
+
+#include <queue>
+
+namespace CGAL {
+
+  /** @file Combinatorial_map_iterators_base.h
+   * Basic classes that serve as tools for definition of iterators.
+   There are 3 classes:
+   *  - CMap_dart_iterator<Map,Const> is the basic generic class defining
+   *    what is an interator on darts.
+   *  - CMap_extend_iterator<Map,Ite,Bi> to extend the given iterator by adding
+   *    the involution Bi.
+   *  - CMap_non_basic_iterator<Map_,Ite> to transform the basic iterator Ite
+   *    into the corresponding non basic iterator.
+   */
+    //****************************************************************************
+  /// OperationState: type to keep the last operation used by the previous ++.
+  typedef char OperationState;
+
+  /// Enum of all the possible operations used by the ++ operator.
+  enum
+    {
+      OP_NONE = -1, ///< Beginning of the iterator (there is not yet operator++).
+      OP_BETAI,     ///< Previous op was the first beta.
+      OP_BETAI_INV, ///< Previous op was the inverse of the first beta.
+      OP_BETAJ,     ///< Previous op was the second beta.
+      OP_BETAK,     ///< Previous op was the third beta.
+      OP_BETA0I,    ///< Previous op was beta0 o the first beta.
+      OP_BETAI1,    ///< Previous op was the first beta o beta1.
+      OP_BETAIJ,    ///< Previous op was the composition of two beta.
+      OP_BETAJI,    ///< Previous op was the composition of two beta.
+      OP_BETA21,     ///< Previous op was beta21.
+      OP_JUMP,      ///< Previous op was a jump .
+      OP_POP,       ///< Previous op pop a dart from a stack or a queue.
+      OP_END        ///< Previous op go out of the iterator.    
+    };
+  //****************************************************************************
+  /** Generic class of iterator onto darts.
+   * Class CMap_dart_iterator is a generic iterator. All the combinatorial
+   * map iterator classes inherit from this class (or one of its subclass).
+   */
+  template < typename Map_,bool Const=false >
+  class CMap_dart_iterator: 
+    public internal::CC_iterator<typename Map_::Dart_container,Const>
+  {
+  public:
+    typedef CMap_dart_iterator<Map_,Const> Self;
+    typedef internal::CC_iterator<typename Map_::Dart_container,Const> Base;
+
+    typedef Base Dart_handle;
+    typedef typename boost::mpl::if_c< Const, const Map_,
+                                       Map_>::type Map;
+
+    typedef std::input_iterator_tag iterator_category;
+    typedef typename Base::value_type value_type;
+    typedef typename Base::difference_type difference_type;
+    typedef typename Base::pointer pointer;
+    typedef typename Base::reference reference;    
+
+    /// true iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
+  public:
+    /// Main constructor.
+    CMap_dart_iterator(Map& amap, Dart_handle adart): 
+      Base(adart),
+      mmap(&amap),
+      mfirst_dart(adart),
+      mprev_op(OP_NONE)
+    {}
+
+    /// == operator.
+    bool operator==(const Self& aiterator) const
+    {
+      return ( ((*this==NULL) && (aiterator==NULL)) ||
+	       (mfirst_dart == aiterator.mfirst_dart && 
+		((const Base&)*this==(const Base&)aiterator)) );
+    }
+
+    /// != operator.
+    bool operator!=(const Self& aiterator) const
+    { return !operator==(aiterator); }
+
+    /// Accessor to the initial dart of the iterator.
+    Dart_handle get_first_dart() const { return mfirst_dart; }
+
+    /// Accessor to the combinatorial map.
+    Map* get_combinatorial_map() const { return mmap; }
+    
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    { set_current_dart(mfirst_dart); mprev_op = OP_NONE; }
+
+    /// Test if the iterator is at its end.
+    bool cont() const { return *this != NULL; }
+
+    /// Get the previous operation used for the last ++.
+    OperationState prev_operation()  const { return mprev_op; }
+
+  protected:
+    /// Set the current dart to a given dart
+    void set_current_dart(Dart_handle adart)
+    { Base::operator=(adart); }
+
+  private:
+    /// operator -- in private to invalidate the base operator.
+    Self& operator--()
+    { return *this; }
+    /// operator -- in private to invalidate the base operator.
+    void operator--(int)
+    {}
+
+  protected:
+    /// test if adart->beta(ai) exists and is not marked for amark
+    bool is_unmarked(Dart_handle adart, unsigned int ai, unsigned amark) const
+    { return !adart->is_free(ai) &&					
+        !mmap->is_marked(adart->beta(ai), amark); }
+
+    /// test if adart->beta(ai)->beta(aj) exists
+    bool exist_betaij(Dart_handle adart, unsigned int ai, unsigned int aj) const
+    { return !adart->is_free(ai) && !adart->beta(ai)->is_free(aj); }
+
+    /// test if adart->beta(ai)->beta(aj) exists and is not marked for amark
+    bool is_unmarked2(Dart_handle adart, unsigned int ai, unsigned int aj,
+		      unsigned amark) const
+    { return exist_betaij(adart,ai,aj) &&
+        !mmap->is_marked(adart->beta(ai)->beta(aj), amark); }
+
+  protected:
+    /// The map containing the darts to iterate on.
+    Map* mmap;
+
+    /// The initial dart of the iterator.
+    Dart_handle mfirst_dart;
+
+    /// The last operation used for the ++ operator.
+    OperationState mprev_op;
+  };
+  //****************************************************************************
+  /* Class CMap_extend_iterator<Map,Ite,Bi> which extend a given iterator by 
+   * adding Bi and by using a stack and a mark.
+   * General case when Ite does not have already a stack.
+   */
+  template <typename Map_,typename Ite,int Bi,
+            typename Ite_has_stack=typename Ite::Use_mark>
+  class CMap_extend_iterator: public Ite
+  {
+  public:
+    typedef CMap_extend_iterator<Map_,Ite,Bi, Ite_has_stack> Self;
+    typedef Ite Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    CGAL_static_assertion( (Bi<=Map::dimension &&
+                            boost::is_same<Ite_has_stack,Tag_false>::value) );
+    
+  public:
+    /// Main constructor.
+    CMap_extend_iterator(Map& amap, Dart_handle adart, int amark):
+      Base(amap, adart),
+      mmark_number(amark),
+      minitial_dart(adart)
+    {
+      if ( adart!=NULL )
+      {
+        this->mmap->mark(adart, mmark_number);
+        if (!(*this)->is_free(Bi))
+          mto_treat.push((*this)->beta(Bi));
+      }
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(mmark_number != -1);
+      Base::operator= ( Base(*this->mmap,minitial_dart) );
+      mto_treat = std::queue<Dart_handle>();
+      this->mmap->mark((*this), mmark_number);
+      if (!(*this)->is_free(Bi))
+        mto_treat.push((*this)->beta(Bi));
+    }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(mmark_number != -1);
+      CGAL_assertion(this->cont());
+
+      Base::operator++();
+
+      if ( !this->cont() )
+      {
+        if ( !mto_treat.empty() )
+        {
+          Dart_handle res=NULL;
+          do
+          {
+            res = mto_treat.front();
+            mto_treat.pop();
+          }
+          while (!mto_treat.empty() &&
+                 this->mmap->is_marked(res, mmark_number));
+          
+          if (!this->mmap->is_marked(res, mmark_number))
+          {
+            Base::operator= ( Base(*this->mmap,res) );
+            this->mprev_op = OP_POP;
+          }
+        }
+      }
+
+      if ( this->cont() )
+      {
+        CGAL_assertion( !this->mmap->is_marked((*this), 
+                                               mmark_number) );
+        this->mmap->mark((*this), mmark_number);
+        
+        if (!(*this)->is_free(Bi) &&
+            !this->mmap->is_marked((*this)->beta(Bi),
+                                   mmark_number))
+          mto_treat.push((*this)->beta(Bi));
+      }
+
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+
+  protected:
+    /// Queue of darts to process.
+    std::queue<Dart_handle> mto_treat;
+
+    /// Index of the used mark.
+    int mmark_number;
+
+    /// Initial dart
+    Dart_handle minitial_dart;
+  };
+  //****************************************************************************
+  /* Class CMap_extend_iterator<Map,Ite,Bi> which extend a given iterator by 
+   * adding Bi and by using a stack and a mark.
+   * Specialization when Ite has already a stack.
+   */
+  template <typename Map_,typename Ite,int Bi>
+  class CMap_extend_iterator<Map_,Ite,Bi,Tag_true>: public Ite
+  {
+  public:
+    typedef CMap_extend_iterator<Map_,Ite,Bi,Tag_true> Self;
+    typedef Ite Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    /// Main constructor.
+    CMap_extend_iterator(Map& amap, Dart_handle adart, int amark):
+      Base(amap, adart, amark)
+    {
+      if (adart!=NULL)
+      {
+        if (!adart->is_free(Bi) &&
+            !this->mmap->is_marked(adart->beta(Bi), this->mmark_number))
+          this->mto_treat.push(adart->beta(Bi));
+      }
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(this->mmark_number != -1);
+      Base::rewind();
+      if (!(*this)->is_free(Bi) &&
+          !this->mmap->is_marked((*this)->beta(Bi),
+                                 this->mmark_number))
+        this->mto_treat.push((*this)->beta(Bi));
+    }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      Base::operator++();
+
+      if ( this->cont() )
+      {
+        if (!(*this)->is_free(Bi) &&
+            !this->mmap->is_marked((*this)->beta(Bi),
+                                   this->mmark_number))
+          this->mto_treat.push((*this)->beta(Bi));
+      }
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+  };
+  //****************************************************************************
+  //* Class CMap_non_basic_iterator allows to transform a basic_iterator onto
+  //* a non basic one, depending if the basic iterator uses mark or not.
+  template <typename Map_,typename Basic_iterator, 
+	    typename Use_mark=typename Basic_iterator::Use_mark>
+  class CMap_non_basic_iterator;
+  //****************************************************************************
+  template <typename Map_,typename Base_>
+  class CMap_non_basic_iterator<Map_,Base_,Tag_true>: 
+    public Base_
+  {
+  public:
+    typedef CMap_non_basic_iterator<Map_,Base_,Tag_true> Self;
+    typedef Base_ Base;
+    
+    typedef typename Base::Map Map;
+    typedef typename Base::Dart_handle Dart_handle;
+
+    /// True iff this iterator is basic
+    typedef Tag_false Basic_iterator;
+
+    CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
+                                           Tag_true>::value) );
+    
+    /// Main constructor.
+    CMap_non_basic_iterator(Map& amap, Dart_handle adart1):
+      Base(amap, adart1, amap.get_new_mark())
+    {}
+
+    /// Destructor.
+    ~CMap_non_basic_iterator()
+    {
+      if (this->mmark_number != -1)
+      {
+        unmark_treated_darts();
+        CGAL_assertion( this->mmap->is_whole_map_unmarked
+                        (this->mmark_number) );
+        this->mmap->free_mark(this->mmark_number);
+      }
+    }
+
+    /// Copy constructor.
+    CMap_non_basic_iterator(const Self& aiterator):
+      Base(aiterator)
+    { this->mmark_number = -1; }
+
+    /// Assignment operator.
+    Self& operator=(const Self& aiterator)
+    {
+      if (this != &aiterator)
+      {
+        Base::operator=(aiterator);
+        this->mmark_number = -1;
+      }
+      return *this;
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(this->mmark_number != -1);
+      unmark_treated_darts();
+      Base::rewind();
+    }
+
+    using Base::operator++;
+
+    /// Postfix ++ operator.
+    void operator++(int)
+    { operator ++(); }
+
+  protected:
+    /// Unmark all the marked darts during the iterator.
+    void unmark_treated_darts()
+    {
+      CGAL_assertion(this->mmark_number != -1);
+      if (this->mmap->is_whole_map_unmarked(this->mmark_number)) return;
+
+      this->mmap->negate_mark(this->mmark_number);
+
+      if (this->mmap->is_whole_map_unmarked(this->mmark_number)) return;
+
+      Base::rewind();
+      while (this->mmap->number_of_unmarked_darts(this->mmark_number) > 0)
+        this->operator++();
+      this->mmap->negate_mark(this->mmark_number);
+      CGAL_assertion(this->mmap->is_whole_map_unmarked(this->mmark_number));
+    }
+  };
+  //****************************************************************************
+  template <typename Map_,typename Base_>
+  class CMap_non_basic_iterator<Map_,Base_,Tag_false>: 
+    public Base_
+  {
+  public:
+    typedef CMap_non_basic_iterator<Map_,Base_,Tag_false> Self;
+    typedef Base_ Base;
+    
+    typedef typename Base::Map Map;
+    typedef typename Base::Dart_handle Dart_handle;
+
+    /// True iff this iterator is basic
+    typedef Tag_false Basic_iterator;
+
+    CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
+                                           Tag_true>::value) );
+    
+    /// Main constructor.
+    CMap_non_basic_iterator(Map& amap, Dart_handle adart):
+      Base(amap, adart,-1)
+    {}
+  };
+  //****************************************************************************
+  template <typename Map_, typename It, typename Const_it,
+            typename Basic_iterator=typename It::Basic_iterator>
+  struct CMap_range
+  {
+    typedef It iterator;
+    typedef Const_it const_iterator;
+    CMap_range(Map_ &amap, typename Map_::Dart_handle adart) :
+      mmap(amap), mdart(adart), msize(0)
+    {}
+    iterator begin()             { return iterator(mmap,mdart); }
+    iterator end()               { return iterator(mmap,NULL); }
+    const_iterator begin() const { return const_iterator(mmap,mdart); }
+    const_iterator end() const   { return const_iterator(mmap,NULL); }
+    typename Map_::size_type size()
+    {
+      if (msize==0)
+        for (const_iterator it=begin(); it!=end(); ++it)
+          ++msize;
+      return msize;
+    }
+    bool empty() const
+    { return mmap.is_empty(); }
+  private:
+    Map_ & mmap;
+    typename Map_::Dart_handle mdart;
+    typename Map_::size_type msize;
+  };
+  //****************************************************************************
+  template <typename Map_, typename It, typename Const_it>
+  struct CMap_range<Map_,It,Const_it,Tag_true>
+  {
+    typedef CMap_range<Map_,It,Const_it,Tag_true> Base_cmap_range;
+    typedef It iterator;
+    typedef Const_it const_iterator;
+    CMap_range(Map_ &amap, typename Map_::Dart_handle adart, int amark=-1):
+      mmap(amap), mdart(adart), msize(0), mmark(amark)
+    {}
+    iterator begin()             { return iterator(mmap,mdart,mmark); }
+    iterator end()               { return iterator(mmap,NULL,mmark); }
+    const_iterator begin() const { return const_iterator(mmap,mdart,mmark); }
+    const_iterator end() const   { return const_iterator(mmap,NULL,mmark); }
+    typename Map_::size_type size()
+    {
+      if (msize==0)
+        for ( CMap_non_basic_iterator<Map_,const_iterator> it(mmap,mdart);
+              it.cont(); ++it )
+          ++msize;
+      return msize;
+    }
+    bool empty() const
+    { return mmap.is_empty(); }
+  private:
+    Map_ & mmap;
+    typename Map_::Dart_handle mdart;
+    typename Map_::size_type msize;
+    int mmark;
+  };
+  //****************************************************************************
+  template <typename Map_, typename Const_it,
+            typename Basic_iterator=typename Const_it::Basic_iterator>
+  struct CMap_const_range
+  {
+    typedef Const_it const_iterator;
+    CMap_const_range(const Map_ &amap, typename Map_::Dart_const_handle adart):
+      mmap(amap), mdart(adart), msize(0)
+    {}
+    const_iterator begin() const { return const_iterator(mmap,mdart); }
+    const_iterator end() const   { return const_iterator(mmap,NULL); }
+    typename Map_::size_type size()
+    {
+      if (msize==0)
+        for (const_iterator it=begin(); it!=end(); ++it)
+          ++msize;
+      return msize;
+    }
+    bool empty() const
+    { return mmap.is_empty(); }
+  private:
+    const Map_ & mmap;
+    typename Map_::Dart_const_handle mdart;
+    typename Map_::size_type msize;
+  };
+  //****************************************************************************
+  template <typename Map_, typename Const_it>
+  struct CMap_const_range<Map_,Const_it,Tag_true>
+  {
+    typedef Const_it const_iterator;
+    CMap_const_range(const Map_ &amap, typename Map_::Dart_const_handle adart,
+               int amark=-1):
+      mmap(amap), mdart(adart), msize(0), mmark(amark)
+    {}
+    const_iterator begin() const { return const_iterator(mmap,mdart,mmark); }
+    const_iterator end() const   { return const_iterator(mmap,NULL,mmark); }
+    typename Map_::size_type size()
+    {
+      if (msize==0)
+        for ( CMap_non_basic_iterator<Map_,const_iterator> it(mmap,mdart);
+              it.cont(); ++it )
+          ++msize;
+      return msize;
+    }
+    bool empty() const
+    { return mmap.is_empty(); }
+  private:
+    const Map_ & mmap;
+    typename Map_::Dart_const_handle mdart;
+    typename Map_::size_type msize;
+    int mmark;
+  };
+  //****************************************************************************
+} // namespace CGAL
+//******************************************************************************
+#endif // CGAL_COMBINATORIAL_MAP_ITERATORS_BASE_HH
+//******************************************************************************
diff --git a/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h b/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h
index 96aa9cbfe03..dc239767b39 100644
--- a/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h
+++ b/Combinatorial_map/include/CGAL/Combinatorial_map_operations.h
@@ -156,7 +156,7 @@ namespace CGAL {
   bool is_removable(const Map& amap, typename Map::Dart_const_handle adart)
   {
     CGAL_assertion(adart != NULL);
-    CGAL_assertion(0<=i && i<=Map::dimension);
+    CGAL_static_assertion(0<=i && i<=Map::dimension);
 
     if ( i==Map::dimension   ) return true;
     if ( i==Map::dimension-1 ) return true;
@@ -183,7 +183,7 @@ namespace CGAL {
   {
     static size_t run(Map& amap, typename Map::Dart_handle adart)
     {
-      CGAL_assertion ( 1<=i && i<Map::dimension );
+      CGAL_static_assertion ( 1<=i && i<Map::dimension );
       CGAL_assertion( (is_removable<Map,i>(amap, adart)) );
       
       size_t res = 0;
@@ -504,7 +504,7 @@ namespace CGAL {
 				      InputIterator afirst, 
 				      InputIterator alast)
   {
-    CGAL_assertion( Map::dimension>= 3 );
+    CGAL_static_assertion( Map::dimension>= 3 );
 
     // The path must have at least one dart.
     if (afirst==alast) return false;
diff --git a/Combinatorial_map/include/CGAL/Dart_const_iterators.h b/Combinatorial_map/include/CGAL/Dart_const_iterators.h
index dde0800692b..8c67353da80 100644
--- a/Combinatorial_map/include/CGAL/Dart_const_iterators.h
+++ b/Combinatorial_map/include/CGAL/Dart_const_iterators.h
@@ -25,15 +25,16 @@
 namespace CGAL {
 
   /** @file Dart_const_iterators.h
-   * Definition of dart const iterators. There are 8 iterators:
+   * Definition of dart const iterators. There are 9 iterators:
    *  - CMap_dart_const_iterator_basic_of_orbit<Map,Beta...>
    *  - CMap_dart_const_iterator_basic_of_cell<Map,i,d>
+   *  - CMap_dart_const_iterator_basic_of_all<Map>
+   *  - CMap_dart_const_iterator_basic_of_involution<Map,i,d>
+   *  - CMap_dart_const_iterator_of_involution_inv<Map,i,d>
    *  - CMap_dart_const_iterator_of_orbit<Map,Beta...>
    *  - CMap_dart_const_iterator_of_cell<Map,i,d>
-   *  - CMap_dart_const_iterator_basic_of_involution<Map,i,d>
    *  - CMap_dart_const_iterator_of_involution<Map,i,d>
    *  - CMap_dart_const_iterator_basic_of_involution_inv<Map,i,d>
-   *  - CMap_dart_const_iterator_of_involution_inv<Map,i,d>
    */
   //****************************************************************************
   #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
@@ -58,6 +59,13 @@ namespace CGAL {
 					   int amark):
       Base(amap,adart,amark)
     {}
+    /// Constructor from non const version.
+    CMap_dart_const_iterator_basic_of_orbit
+    (const CMap_dart_iterator_basic_of_orbit<Map_,Beta...>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart(),
+	   it.mmark_number)
+    {}
   };
   //****************************************************************************
   template<typename Map_,unsigned int...Beta>
@@ -109,6 +117,14 @@ namespace CGAL {
 					   int amark):
       Base(amap,adart,amark)
     {}
+    /// Constructor from non const version.
+    CMap_dart_const_iterator_basic_of_orbit
+    (const CMap_dart_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
+					     B7,B8,B9>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart(),
+	   it.mmark_number)
+    {}
   };
   //****************************************************************************
   template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1, 
@@ -139,6 +155,33 @@ namespace CGAL {
   };
   #endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   //****************************************************************************
+  template<typename Map_>
+  class CMap_dart_const_iterator_basic_of_all:
+    public CMap_dart_iterator_basic_of_all<Map_,true>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_all<Map_,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */				       
+    CMap_dart_const_iterator_basic_of_all(const Map_& amap, 
+                                          Dart_const_handle adart):
+      Base(amap,adart)
+    {}                                         
+    /* Main constructor. */				       
+    CMap_dart_const_iterator_basic_of_all(const Map_& amap,
+                                          Dart_const_handle adart,
+                                          int /*amark*/):
+      Base(amap,adart)
+    {}                                                         
+    /// Constructor from non const version.
+    CMap_dart_const_iterator_basic_of_all
+    (const CMap_dart_iterator_basic_of_all<Map_,false>& it):
+     Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	  it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
   template<typename Map_,int i,int d=Map_::dimension>
   class CMap_dart_const_iterator_basic_of_cell:
     public CMap_dart_iterator_basic_of_cell<Map_,i,d,true>
diff --git a/Combinatorial_map/include/CGAL/Dart_iterators.h b/Combinatorial_map/include/CGAL/Dart_iterators.h
index e3907ff515c..5b42ab28d2f 100644
--- a/Combinatorial_map/include/CGAL/Dart_iterators.h
+++ b/Combinatorial_map/include/CGAL/Dart_iterators.h
@@ -20,151 +20,25 @@
 #ifndef CGAL_DART_ITERATORS_HH
 #define CGAL_DART_ITERATORS_HH 1
 
-#include <queue>
+#include <CGAL/Combinatorial_map_iterators_base.h>
 
 namespace CGAL {
 
   /** @file Dart_iterators.h
    * Definition of dart iterators. There are 9 iterators:
-   *  - CMap_dart_iterator_basic_of_orbit<Map,Beta...>
-   *  - CMap_dart_iterator_basic_of_cell<Map,i,d>
-   *  - CMap_dart_iterator_basic_of_all
-   *  - CMap_dart_iterator_of_orbit<Map,Beta...>
-   *  - CMap_dart_iterator_of_cell<Map,i,d>
-   *  - CMap_dart_iterator_basic_of_involution<Map,i,d>
-   *  - CMap_dart_iterator_of_involution<Map,i,d>
-   *  - CMap_dart_iterator_basic_of_involution_inv<Map,i,d>
-   *  - CMap_dart_iterator_of_involution_inv<Map,i,d>
+   * - CMap_dart_iterator_basic_of_orbit<Map,Beta...>
+   * - CMap_dart_iterator_basic_of_cell<Map,i,d>
+   * - CMap_dart_iterator_basic_of_all
+   * - CMap_dart_iterator_basic_of_involution<Map,i,d>
+   * - CMap_dart_iterator_basic_of_involution_inv<Map,i,d>
+   * - CMap_dart_iterator_of_orbit<Map,Beta...>
+   * - CMap_dart_iterator_of_cell<Map,i,d>
+   * - CMap_dart_iterator_of_involution<Map,i,d>
+   * - CMap_dart_iterator_of_involution_inv<Map,i,d>
    * but many specializations to optimize specific cases.
    *  
    */
   //****************************************************************************
-  /// OperationState: type to keep the last operation used by the previous ++.
-  typedef char OperationState;
-
-  /// Enum of all the possible operations used by the ++ operator.
-  enum
-    {
-      OP_NONE = -1, ///< Beginning of the iterator (there is not yet operator++).
-      OP_BETAI,     ///< Previous op was the first beta.
-      OP_BETAI_INV, ///< Previous op was the inverse of the first beta.
-      OP_BETAJ,     ///< Previous op was the second beta.
-      OP_BETAK,     ///< Previous op was the third beta.
-      OP_BETA0I,    ///< Previous op was beta0 o the first beta.
-      OP_BETAI1,    ///< Previous op was the first beta o beta1.
-      OP_BETAIJ,    ///< Previous op was the composition of two beta.
-      OP_BETAJI,    ///< Previous op was the composition of two beta.
-      OP_BETA21,     ///< Previous op was beta21.
-      OP_JUMP,      ///< Previous op was a jump .
-      OP_POP,       ///< Previous op pop a dart from a stack or a queue.
-      OP_END        ///< Previous op go out of the iterator.    
-    };
-  //****************************************************************************
-  //****************************************************************************
-  /** Generic class of iterator onto darts.
-   * Class CMap_dart_iterator is a pure virtual generic iterator. This
-   * class defines what is an iterator. All the iterator classes inherit
-   * from this class.
-   */
-  template < typename Map_,bool Const=false >
-  class CMap_dart_iterator: 
-    public internal::CC_iterator<typename Map_::Dart_container,Const>
-  {
-  public:
-    typedef CMap_dart_iterator<Map_,Const> Self;
-    typedef internal::CC_iterator<typename Map_::Dart_container,Const> Base;
-
-    typedef Base Dart_handle;
-    typedef typename boost::mpl::if_c< Const, const Map_,
-                                       Map_>::type Map;
-
-    typedef std::input_iterator_tag iterator_category;
-    typedef typename Base::value_type value_type;
-    typedef typename Base::difference_type difference_type;
-    typedef typename Base::pointer pointer;
-    typedef typename Base::reference reference;    
-
-  public:
-    /// Main constructor.
-    CMap_dart_iterator(Map& amap, Dart_handle adart): 
-      Base(adart),
-      mmap(&amap),
-      mfirst_dart(adart),
-      mprev_op(OP_NONE)
-    {}
-
-    /// == operator.
-    bool operator==(const Self& aiterator) const
-    {
-      return ( ((*this==NULL) && (aiterator==NULL)) ||
-	       (mfirst_dart == aiterator.mfirst_dart && 
-		((const Base&)*this==(const Base&)aiterator)) );
-    }
-
-    /// != operator.
-    bool operator!=(const Self& aiterator) const
-    { return !operator==(aiterator); }
-
-    /// Accessor to the initial dart of the iterator.
-    Dart_handle get_first_dart() const { return mfirst_dart; }
-
-    /// Accessor to the combinatorial map.
-    Map* get_combinatorial_map() const { return mmap; }
-    
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    { set_current_dart(mfirst_dart); mprev_op = OP_NONE; }
-
-    /// Test if the iterator is at its end.
-    bool cont() const { return *this != NULL; }
-
-    /// Get the previous operation used for the last ++.
-    OperationState prev_operation()  const { return mprev_op; }
-
-    /// Return true iff this iterator is basic
-    static bool is_basic_iterator()
-    { return true; }
-    
-  protected:
-    /// Set the current dart to a given dart
-    void set_current_dart(Dart_handle adart)
-    { Base::operator=(adart); }
-
-  private:
-    /// operator -- in private to invalidate the base operator.
-    Self& operator--()
-    { return *this; }
-    /// operator -- in private to invalidate the base operator.
-    void operator--(int)
-    {}
-
-  protected:
-    /// test if adart->beta(ai) exists and is not marked for amark
-    bool is_unmarked(Dart_handle adart, unsigned int ai, unsigned amark) const
-    { return !adart->is_free(ai) &&					
-	!mmap->is_marked(adart->beta(ai), amark); }
-
-    /// test if adart->beta(ai)->beta(aj) exists
-    bool exist_betaij(Dart_handle adart, unsigned int ai, unsigned int aj) const
-    { return !adart->is_free(ai) && !adart->beta(ai)->is_free(aj); }
-
-    /// test if adart->beta(ai)->beta(aj) exists and is not marked for amark
-    bool is_unmarked2(Dart_handle adart, unsigned int ai, unsigned int aj,
-		      unsigned amark) const
-    { return exist_betaij(adart,ai,aj) &&
-	!mmap->is_marked(adart->beta(ai)->beta(aj), amark); }
-
-  protected:
-    /// The map containing the darts to iterate on.
-    Map* mmap;
-
-    /// The initial dart of the iterator.
-    Dart_handle mfirst_dart;
-
-    /// The last operation used for the ++ operator.
-    OperationState mprev_op;
-  };
-  //****************************************************************************
   //**********************BASIC ITERATORS***************************************
   //****************************************************************************
   /* Class CMap_dart_iterator_basic_of_orbit<Map, Beta...>: to iterate
@@ -258,73 +132,6 @@ namespace CGAL {
 					      -1,-1,-1,-1,-1,-1,-1,-1,-1>
   {
     typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const> type;
-  };
-  
-  template <typename Map_,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
-	    int B7,int B8,int B9>
-  class CMap_dart_iterator_basic_of_orbit_generic: 
-    public Get_CMap_dart_iterator_basic_of_orbit<Map_,Const,B2,B3,B4,B5,
-						B6,B7,B8,B9>::type
-  {
-  public:
-    typedef typename Get_CMap_dart_iterator_basic_of_orbit<Map_,Const,B1,B2,B3,
-							  B4,B5,B6,B7,B8,
-							  B9>::type Self;
-    typedef typename Get_CMap_dart_iterator_basic_of_orbit<Map_,Const,B2,B3,B4,
-							  B5,B6,B7,B8,
-							  B9>::type Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_true Use_mark;
-
-  public:
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
-					     int amark):
-      Base(amap, adart, amark)
-    { 
-      CGAL_assertion( B1>=0 && B1<=Map::dimension );
-
-      if (adart!=NULL)
-	{
-	  if (!adart->is_free(B1) &&
-	      !this->mmap->is_marked(adart->beta(B1), this->mmark_number))
-	    this->mto_treat.push(adart->beta(B1));
-	}
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(this->mmark_number != -1);
-      Base::rewind();
-      if (!(*this)->is_free(B1) &&
-	  !this->mmap->is_marked((*this)->beta(B1), this->mmark_number))
-	this->mto_treat.push((*this)->beta(B1));
-    }
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      CGAL_assertion(this->cont());
-
-      Base::operator++();
-
-      if (this->cont())
-	{
-	  if (!(*this)->is_free(B1) &&
-	      !this->mmap->is_marked((*this)->beta(B1), 
-				     this->mmark_number))
-	    this->mto_treat.push((*this)->beta(B1));
-	}
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
   };  
   #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   //****************************************************************************
@@ -580,13 +387,13 @@ namespace CGAL {
     /// Main constructor.
     CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart):
       Base(amap, adart)
-    { CGAL_assertion( Bi>=2 && Bi<=Map::dimension ); }
+    { CGAL_static_assertion( Bi>=2 && Bi<=Map::dimension ); }
 
     /// Main constructor.
     CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart,
 					     int /*amark*/):
       Base(amap, adart)
-    { CGAL_assertion( Bi>=2 && Bi<=Map::dimension ); }
+    { CGAL_static_assertion( Bi>=2 && Bi<=Map::dimension ); }
 
     /// Prefix ++ operator.
     Self& operator++()
@@ -610,145 +417,19 @@ namespace CGAL {
     { Self res=*this; operator ++(); return res; }
   };
   //****************************************************************************
-  /* Class CMap_extend_iterator<Map,Ite,Bi> which extend a given iterator by 
-   * adding Bi and by using a stack and a mark.
-   */
-  template <typename Map_,typename Ite,int Bi>
-  class CMap_extend_iterator: public Ite
-  {
-  public:
-    typedef CMap_extend_iterator<Map_,Ite,Bi> Self;
-    typedef Ite Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_true Use_mark;
-
-  public:
-    /// Main constructor.
-    CMap_extend_iterator(Map& amap, Dart_handle adart, int amark):
-      Base(amap, adart),
-      mmark_number(amark),
-      minitial_dart(adart)
-    {
-      if ( adart!=NULL )
-	{
-	  this->mmap->mark(adart, mmark_number);
-	  if (!(*this)->is_free(Bi))
-	    mto_treat.push((*this)->beta(Bi));
-	}
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(mmark_number != -1);
-      Base::operator= ( Base(*this->mmap,minitial_dart) );
-      mto_treat = std::queue<Dart_handle>();
-      this->mmap->mark((*this), mmark_number);
-      if (!(*this)->is_free(Bi))
-	mto_treat.push((*this)->beta(Bi));
-    }
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      CGAL_assertion(mmark_number != -1);
-      CGAL_assertion(this->cont());
-
-      Base::operator++();
-
-      if ( !this->cont() )
-	{
-	  if ( !mto_treat.empty() )
-	    {
-	      Dart_handle res=NULL;
-	      do
-		{
-		  res = mto_treat.front();
-		  mto_treat.pop();
-		}
-	      while (!mto_treat.empty() &&
-		     this->mmap->is_marked(res, mmark_number));
-
-	      if (!this->mmap->is_marked(res, mmark_number))
-		{
-		  Base::operator= ( Base(*this->mmap,res) );
-		  this->mprev_op = OP_POP;
-		}
-	    }
-	}
-
-      if ( this->cont() )
-	{
-	  CGAL_assertion( !this->mmap->is_marked((*this), 
-						 mmark_number) );
-	  this->mmap->mark((*this), mmark_number);
-	  
-	  if (!(*this)->is_free(Bi) &&
-	      !this->mmap->is_marked((*this)->beta(Bi),
-				     mmark_number))
-            mto_treat.push((*this)->beta(Bi));
-	}
-
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
-
-  protected:
-    /// Queue of darts to process.
-    std::queue<Dart_handle> mto_treat;
-
-    /// Index of the used mark.
-    int mmark_number;
-
-    /// Initial dart
-    Dart_handle minitial_dart;
-  };
-  //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_orbit<Bi,Bi>: to iterate
-   * on the darts of the orbit <Bi,Bj>: Bi<Bj<=dimension and (Bi,Bj)!=(0,1)
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * This general case if for Bi>1 and delta>1.
    * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
    * the destructor, possible problem with the rewind). If you are not sure,
-   * use CMap_dart_iterator_basic_of_orbit.
+   * use CMap_dart_iterator_basic_of_two_beta.
    */
-  template <typename Map_,bool Const,int Bi,int Bj>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj>: 
-    public CMap_extend_iterator<Map_,CMap_dart_iterator_basic_of_orbit_generic
-				<Map_,Const,Bi>, Bj>
-  {
-  public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj> Self;
-    typedef CMap_extend_iterator<Map_,CMap_dart_iterator_basic_of_orbit_generic
-				 <Map_,Const,Bi>, Bj> Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_true Use_mark;
-
-  public:
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
-					     int amark):
-      Base(amap, adart, amark)
-    { CGAL_assertion( Bi<Bj && Bj!=1 && Bj<=Map::dimension ); }
-  };
-  //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_orbit<Map,0,3>: to iterate onto the
-   * darts of the orbit <beta0, beta3> (i.e. orbit facet in 3D).
-   * Specialized here since we do not need queue nor mark.
-   */
-  template<typename Map_,bool Const>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,0,3>: 
+  template <typename Map_,bool Const,int Bi,unsigned int delta>
+  class CMap_dart_iterator_basic_of_two_beta :
     public CMap_dart_iterator<Map_,Const>
   {
   public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,0,3> Self;
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,Bi,delta> Self;
     typedef CMap_dart_iterator<Map_,Const> Base;
 
     typedef typename Base::Dart_handle Dart_handle;
@@ -756,52 +437,238 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    CGAL_static_assertion( Bi>1 && delta>1 && Bi+delta<=Map::dimension );
+    
   public:
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart):
       Base(amap, adart),
-      mit(amap, adart),
-      mexist_beta3(false),
-      mprev_beta3(false),
-      mfirst_border(true)
-    { if (adart!=NULL) mexist_beta3=!adart->is_free(3); }
+      mcurdart(0)
+    {}
 
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
-					     int /*amark*/):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart, 
+                                         int /*amark*/):
       Base(amap, adart),
-      mit(amap, adart),
-      mexist_beta3(false),
-      mprev_beta3(false),
-      mfirst_border(true)
-    { if (adart!=NULL) mexist_beta3=!adart->is_free(3); }
+      mcurdart(0)
+    {}    
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      Base::rewind();
+      mcurdart=0;
+    }
 
     /// Prefix ++ operator.
     Self& operator++()
     {
       CGAL_assertion(this->cont());
-      if (mexist_beta3 && !mprev_beta3)
-	{
-	  mprev_beta3 = true;
-	  mfirst_border = ! mfirst_border;
-	  this->set_current_dart((*this)->beta(3));
-	  this->mprev_op = OP_BETAJ;
-	}
+
+      if (mcurdart==0)
+      {
+        if (!(*this)->is_free(Bi))
+        {
+          this->set_current_dart((*this)->beta(Bi));
+          this->mprev_op = OP_BETAI;
+          mcurdart=1;
+        }
+        else
+        {
+          if (!(*this)->is_free(Bi+delta))
+          {
+            this->set_current_dart((*this)->beta(Bi+delta));
+            this->mprev_op = OP_BETAJ;
+            mcurdart=3;
+          }
+          else
+          {
+            this->mprev_op = OP_END;
+            this->set_current_dart(NULL);
+          }
+        }
+      }
+      else if (mcurdart==1)
+      {
+        if (!(*this)->is_free(Bi+delta))
+        {
+          this->set_current_dart((*this)->beta(Bi+delta));
+          this->mprev_op = OP_BETAJ;
+          mcurdart=2;
+        }
+        else
+        {
+          this->mprev_op = OP_END;
+          this->set_current_dart(NULL);
+        }
+      }
+      else if (mcurdart==2)
+      {
+        CGAL_assertion(!(*this)->is_free(Bi));
+        this->set_current_dart((*this)->beta(Bi));
+        this->mprev_op = OP_BETAI;
+        mcurdart=1;
+      }
+      else 
+      {
+        CGAL_assertion (mcurdart==3);
+        this->mprev_op = OP_END;
+        this->set_current_dart(NULL);
+      }
+			
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+
+  private:
+    /// mcurdart: number of the current dart (0,1,2 or 3).
+    char mcurdart;
+  };
+  //****************************************************************************
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * Special case for Bi==0 and delta==2.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_two_beta.
+   */
+template <typename Map_,bool Const>
+  class CMap_dart_iterator_basic_of_two_beta<Map_,Const,0,2> :
+    public CMap_extend_iterator
+               <Map_,
+                CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,0>,
+                2>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,0,2> Self;
+    typedef CMap_extend_iterator
+               <Map_,
+                CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,0>,
+                2> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    CGAL_static_assertion( 2<=Map::dimension );
+    
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart, 
+                                         int amark):
+      Base(amap, adart, amark)
+    {}
+  };
+  //****************************************************************************
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * Special case for Bi==1 and delta==1.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_two_beta.
+   */
+  template <typename Map_,bool Const>
+  class CMap_dart_iterator_basic_of_two_beta<Map_,Const,1,1> :
+    public CMap_extend_iterator
+             <Map_,
+              CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,1>,
+              2>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,1,1> Self;
+    typedef CMap_extend_iterator
+              <Map_,
+               CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,1>,
+               2>
+               Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    CGAL_static_assertion( 2<=Map::dimension );
+    
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart, 
+                                         int amark):
+      Base(amap, adart, amark)
+    {}
+  };
+  //****************************************************************************
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * Special case for Bi==0 and delta>2.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_two_beta.
+   */
+  template <typename Map_,bool Const, unsigned int delta>
+  class CMap_dart_iterator_basic_of_two_beta<Map_,Const,0,delta> :
+    public CMap_dart_iterator<Map_,Const>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,0,delta> Self;
+    typedef CMap_dart_iterator<Map_,Const> Base;
+    
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_false Use_mark;
+
+    CGAL_static_assertion( delta>1 && delta<=Map::dimension );
+
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart):
+      Base(amap, adart),
+      mit(amap, adart),
+      mexist_betaj(false),
+      mprev_betaj(false),
+      mfirst_border(true)
+    { if (adart!=NULL) mexist_betaj=!adart->is_free(delta); }
+    
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart, 
+                                         int /*amark*/):
+      Base(amap, adart),
+      mit(amap, adart),
+      mexist_betaj(false),
+      mprev_betaj(false),
+      mfirst_border(true)
+    { if (adart!=NULL) mexist_betaj=!adart->is_free(delta); }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(this->cont());
+      if (mexist_betaj && !mprev_betaj)
+      {
+        mprev_betaj = true;
+        mfirst_border = ! mfirst_border;
+        this->set_current_dart((*this)->beta(delta));
+        this->mprev_op = OP_BETAJ;
+      }
       else
-	{
-	  mprev_beta3 = false;
-	  ++mit;
-	  this->mprev_op = mit.prev_operation();
-	  if ( !mit.cont() ) 
-	    this->set_current_dart(NULL);
-	  else
-	    {	  
-	      if ( !mfirst_border ) 
-		this->set_current_dart(mit->beta(3));
-	      else
-		this->set_current_dart(*mit);
-	    }
-	}
+      {
+        mprev_betaj = false;
+        ++mit;
+        this->mprev_op = mit.prev_operation();
+        if ( !mit.cont() ) 
+          this->set_current_dart(NULL);
+        else
+        {	  
+          if ( !mfirst_border ) 
+            this->set_current_dart(mit->beta(delta));
+          else
+            this->set_current_dart(mit);
+        }
+      }
       return *this;
     }
 
@@ -814,7 +681,7 @@ namespace CGAL {
     {
       Base::rewind();
       mit.rewind();
-      mprev_beta3   = false;
+      mprev_betaj   = false;
       mfirst_border = true;
     }
 
@@ -823,78 +690,83 @@ namespace CGAL {
     CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,0> mit;
 
     /// Boolean: true iff there are two half facets.
-    bool mexist_beta3;
+    bool mexist_betaj;
 
-    /// Boolean: true iff the last ++ used beta3.
-    bool mprev_beta3;
+    /// Boolean: true iff the last ++ used betaj.
+    bool mprev_betaj;
 
     /// Boolean: true iff the current dart is on the first border.
     bool mfirst_border;
   };
   //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_orbit<Map,1,3>: to iterate onto the
-   * darts of the orbit <beta1, beta3> (i.e. orbit facet in 3D).
-   * Specialized here since we do not need queue nor mark.
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * Special case for Bi==1 and delta>1.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_two_beta.
    */
-  template<typename Map_,bool Const>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,1,3>: 
+  template <typename Map_,bool Const, unsigned int delta>
+  class CMap_dart_iterator_basic_of_two_beta<Map_,Const,1,delta> :
     public CMap_dart_iterator<Map_,Const>
   {
   public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,1,3> Self;
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,1,delta> Self;
     typedef CMap_dart_iterator<Map_,Const> Base;
-
+    
     typedef typename Base::Dart_handle Dart_handle;
     typedef typename Base::Map Map;
 
     typedef Tag_false Use_mark;
 
+    CGAL_static_assertion( delta>1 && delta+1<=Map::dimension );
+
   public:
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart):
       Base(amap, adart),
       mit(amap, adart),
-      mexist_beta3(false),
-      mprev_beta3(false),
+      mexist_betaj(false),
+      mprev_betaj(false),
       mfirst_border(true)
-    { if (adart!=NULL) mexist_beta3=!adart->is_free(3); }
-
+    { if (adart!=NULL) mexist_betaj=!adart->is_free(1+delta); }
+    
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
-					     int /*amark*/):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart, 
+                                         int /*amark*/):
       Base(amap, adart),
       mit(amap, adart),
-      mexist_beta3(false),
-      mprev_beta3(false),
+      mexist_betaj(false),
+      mprev_betaj(false),
       mfirst_border(true)
-    { if (adart!=NULL) mexist_beta3=!adart->is_free(3); }
+    { if (adart!=NULL) mexist_betaj=!adart->is_free(1+delta); }
 
     /// Prefix ++ operator.
     Self& operator++()
     {
       CGAL_assertion(this->cont());
-      if (mexist_beta3 && !mprev_beta3)
-	{
-	  mprev_beta3 = true;
-	  mfirst_border = ! mfirst_border;
-	  this->set_current_dart((*this)->beta(3));
-	  this->mprev_op = OP_BETAJ;
-	}
+      if (mexist_betaj && !mprev_betaj)
+      {
+        mprev_betaj = true;
+        mfirst_border = ! mfirst_border;
+        this->set_current_dart((*this)->beta(1+delta));
+        this->mprev_op = OP_BETAJ;
+      }
       else
-	{
-	  mprev_beta3 = false;
-	  ++mit;
-	  this->mprev_op = mit.prev_operation();
-	  if ( !mit.cont() ) 
-	    this->set_current_dart(NULL);
-	  else
-	    {	  
-	      if ( !mfirst_border ) 
-		this->set_current_dart(mit->beta(3));
-	      else
-		this->set_current_dart(mit);
-	    }
-	}
+      {
+        mprev_betaj = false;
+        ++mit;
+        this->mprev_op = mit.prev_operation();
+        if ( !mit.cont() ) 
+          this->set_current_dart(NULL);
+        else
+        {	  
+          if ( !mfirst_border ) 
+            this->set_current_dart(mit->beta(1+delta));
+          else
+            this->set_current_dart(mit);
+        }
+      }
       return *this;
     }
 
@@ -907,33 +779,37 @@ namespace CGAL {
     {
       Base::rewind();
       mit.rewind();
-      mprev_beta3   = false;
+      mprev_betaj   = false;
       mfirst_border = true;
     }
 
   private:
     /// Iterator on beta1
-    CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,1> mit;
+    CMap_dart_iterator_basic_of_orbit_generic<Map_,Const, 1> mit;
 
     /// Boolean: true iff there are two half facets.
-    bool mexist_beta3;
+    bool mexist_betaj;
 
-    /// Boolean: true iff the last ++ used beta3.
-    bool mprev_beta3;
+    /// Boolean: true iff the last ++ used betaj.
+    bool mprev_betaj;
 
     /// Boolean: true iff the current dart is on the first border.
     bool mfirst_border;
   };
   //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_orbit<Map,2,3>: to iterate onto the
-   * darts of the orbit <beta2, beta3> (i.e. orbit edge in 3D).
+  /* Class CMap_dart_iterator_basic_of_two_beta<Bi,delta>: to iterate
+   * on the darts of the orbit <Bi,Bi+delta>: Bi<Bi+delta<=dimension.
+   * Special case for Bi>1 and delta==1.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_two_beta.
    */
-  template <typename Map_,bool Const>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,2,3>: 
+  template <typename Map_,bool Const, int Bi>
+  class CMap_dart_iterator_basic_of_two_beta<Map_,Const,Bi,1> :
     public CMap_dart_iterator<Map_,Const>
   {
   public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,2,3> Self;
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,Bi,1> Self;
     typedef CMap_dart_iterator<Map_,Const> Base;
     
     typedef typename Base::Dart_handle Dart_handle;
@@ -941,124 +817,126 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    CGAL_static_assertion( Bi>1 && Bi+1<=Map::dimension );
+
   public:
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart):    
       Base(amap, adart),
       mfirst_dir(true),
-      mnext_try_beta2(true)
+      mnext_try_betai(true)
     {}
 
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart,
-					     int /*amark*/):
+    CMap_dart_iterator_basic_of_two_beta(Map& amap, Dart_handle adart,
+                                         int /*amark*/):
       Base(amap, adart),
       mfirst_dir(true),
-      mnext_try_beta2(true)
+      mnext_try_betai(true)
     {}
-
+    
     /// Rewind of the iterator to its beginning.
     void rewind()
     {
       Base::rewind();
       mfirst_dir = true;
-      mnext_try_beta2   = true;
+      mnext_try_betai   = true;
     }
 
     /// Prefix ++ operator.
     Self& operator++()
     {
       CGAL_assertion(this->cont());
-
+      
       if (mfirst_dir)
-	{
-	  if (mnext_try_beta2)
-	    {
-	      if ((*this)->is_free(2))
-		{
-		  mfirst_dir = false;
-		  if (this->mfirst_dart->is_free(3))
-		    {
-		      this->mprev_op = OP_END;
-		      this->set_current_dart(NULL);
-		    }
-		  else
-		    {
-		      this->set_current_dart(this->mfirst_dart->beta(3));
-		      this->mprev_op = OP_JUMP;
-		    }
-		}
-	      else
-		{
-		  this->set_current_dart((*this)->beta(2));
-		  mnext_try_beta2 = false;
-		  this->mprev_op = OP_BETAI;
-		}
-	    }
-	  else
-	    {
-	      if ((*this)->is_free(3))
-		{
-		  mfirst_dir = false;
-		  if (this->mfirst_dart->is_free(3))
-		    {
-		      this->mprev_op = OP_END;
-		      this->set_current_dart(NULL);
-		    }
-		  else
-		    {
-		      this->set_current_dart(this->mfirst_dart->beta(3));
-		      mnext_try_beta2 = true;
-		      this->mprev_op = OP_JUMP;
-		    }
-		}
-	      else
-		{
-		  this->set_current_dart((*this)->beta(3));
-		  if ((*this)==this->mfirst_dart)
-		    {
-		      this->mprev_op = OP_END;
-		      this->set_current_dart(NULL);
-		    }
-		  else
-		    {
-		      mnext_try_beta2 = true;
-		      this->mprev_op = OP_BETAJ;
-		    }
-		}
-	    }
-	}
+      {
+        if (mnext_try_betai)
+        {
+          if ((*this)->is_free(Bi))
+          {
+            mfirst_dir = false;
+            if (this->mfirst_dart->is_free(Bi+1))
+            {
+              this->mprev_op = OP_END;
+              this->set_current_dart(NULL);
+            }
+            else
+            {
+              this->set_current_dart(this->mfirst_dart->beta(Bi+1));
+              this->mprev_op = OP_JUMP;
+            }
+          }
+          else
+          {
+            this->set_current_dart((*this)->beta(Bi));
+            mnext_try_betai = false;
+            this->mprev_op = OP_BETAI;
+          }
+        }
+        else
+        {
+          if ((*this)->is_free(Bi+1))
+          {
+            mfirst_dir = false;
+            if (this->mfirst_dart->is_free(Bi+1))
+            {
+              this->mprev_op = OP_END;
+              this->set_current_dart(NULL);
+            }
+            else
+            {
+              this->set_current_dart(this->mfirst_dart->beta(Bi+1));
+              mnext_try_betai = true;
+              this->mprev_op = OP_JUMP;
+            }
+          }
+          else
+          {
+            this->set_current_dart((*this)->beta(Bi+1));
+            if ((*this)==this->mfirst_dart)
+            {
+              this->mprev_op = OP_END;
+              this->set_current_dart(NULL);
+            }
+            else
+            {
+              mnext_try_betai = true;
+              this->mprev_op = OP_BETAJ;
+            }
+          }
+        }
+      }
       else
-	{
-	  if (mnext_try_beta2)
-	    {
-	      if ((*this)->is_free(2))
-		{
-		  this->mprev_op = OP_END;
-		  this->set_current_dart(NULL);
-		}
-	      else
-		{
-		  this->set_current_dart((*this)->beta(2));
-		  mnext_try_beta2 = false;
-		  this->mprev_op = OP_BETAI;
-		}
-	    }
-	  else
-	    {
-	      if ((*this)->is_free(3))
-		{
-		  this->mprev_op = OP_END;
-		  this->set_current_dart(NULL);
-		}
-	      else
-		{
-		  this->set_current_dart((*this)->beta(3));
-		  mnext_try_beta2 = true;
-		  this->mprev_op = OP_BETAJ;
-		}
-	    }
-	}
+      {
+        if (mnext_try_betai)
+        {
+          if ((*this)->is_free(Bi))
+          {
+            this->mprev_op = OP_END;
+            this->set_current_dart(NULL);
+          }
+          else
+          {
+            this->set_current_dart((*this)->beta(Bi));
+            mnext_try_betai = false;
+            this->mprev_op = OP_BETAI;
+          }
+        }
+        else
+        {
+          if ((*this)->is_free(Bi+1))
+          {
+            this->mprev_op = OP_END;
+            this->set_current_dart(NULL);
+          }
+          else
+          {
+            this->set_current_dart((*this)->beta(Bi+1));
+            mnext_try_betai = true;
+            this->mprev_op = OP_BETAJ;
+          }
+        }
+      }
       return *this;
     }
 
@@ -1067,103 +945,111 @@ namespace CGAL {
     { Self res=*this; operator ++(); return res; }
 
   private:
-    /// Boolean: true iff we turn in the first direction (i.e. using beta2).
+    /// Boolean: true iff we turn in the first direction (i.e. using betai).
     bool mfirst_dir;
 
-    /// Boolean: true iff the next ++ must use beta2.
-    bool mnext_try_beta2;
+    /// Boolean: true iff the next ++ must use betai.
+    bool mnext_try_betai;
   };
   //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_orbit<Map,Bi,Bj,Bk>: to iterate onto 
-   * the darts of the orbit <Bi,Bj,Bk>, Bi<Bj<Bk<=dimension 
-   * Basic classes do not guaranty correct marks (i.e. do not unmark
-   * darts in the destructor, possible problem with the rewind).
-   * not for <B0,B3,Bk>, <B1,B3,Bk>, <B2,B3,Bk> which are specific cases.
+  /* Class CMap_dart_iterator_basic_of_orbit<Bi,Bj>: to iterate
+   * on the darts of the orbit <Bi,Bj>: Bi<Bj<=dimension.
+   * Basic classes do not guaranty correct marks (i.e. do not unmark darts in
+   * the destructor, possible problem with the rewind). If you are not sure,
+   * use CMap_dart_iterator_basic_of_orbit.
    */
-  template <typename Map_,int Bi,int Bj,int Bk,bool Const>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj,Bk>: 
-    public CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj>
+  template <typename Map_,bool Const,int Bi,int Bj>
+  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj>: 
+    public CMap_dart_iterator_basic_of_two_beta<Map_,Const,Bi,Bj-Bi>
   {
   public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj,Bk> Self;
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj> Base;
+    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj> Self;
+    typedef CMap_dart_iterator_basic_of_two_beta<Map_,Const,Bi,Bj-Bi> Base;
 
     typedef typename Base::Dart_handle Dart_handle;
     typedef typename Base::Map Map;
 
-    typedef Tag_true Use_mark;
+    typedef typename Base::Use_mark Use_mark;
+
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart) :
+      Base(amap, adart)
+    {}    
+
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
+                                              int amark):
+      Base(amap, adart, amark)
+    {}    
+  };
+  //****************************************************************************
+  /* Generic nD version. 
+   */
+#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+  template <typename Map_,bool Const,int Bi,int Bj, int Bk, int... Beta>
+  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj,Bk,Beta...>: 
+    public CMap_extend_iterator<Map_,
+                                CMap_dart_iterator_basic_of_orbit_generic
+                                <Map_,Const,Bi,Bj,Beta...>,
+                                Bk>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_orbit_generic
+               <Map_,Const,Bi,Bj,Bk,Beta...> Self;
+    typedef CMap_extend_iterator<Map_,
+                                 CMap_dart_iterator_basic_of_orbit_generic
+                                 <Map_,Const,Bi,Bj,Beta...>,
+                                 Bk> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
 
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
-					     int amark):
+                                              int amark):
       Base(amap, adart, amark)
-    {
-      CGAL_assertion( Bi<Bj && Bj<Bk && Bj!=1 && Bk<=Map::dimension );
-
-      if (adart!=NULL)
-	{
-	  if (!adart->is_free(Bk) &&
-	      !this->mmap->is_marked(adart->beta(Bk), this->mmark_number))
-	    this->mto_treat.push(adart->beta(Bk));
-	}
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(this->mmark_number != -1);
-      Base::rewind();
-      if (!(*this)->is_free(Bk) &&
-	  !this->mmap->is_marked((*this)->beta(Bk),
-				 this->mmark_number))
-	this->mto_treat.push((*this)->beta(Bk));
-    }
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      Base::operator++();
-
-      if ( this->cont() )
-	{
-	  if (!(*this)->is_free(Bk) &&
-	      !this->mmap->is_marked((*this)->beta(Bk),
-				     this->mmark_number))
-            this->mto_treat.push((*this)->beta(Bk));
-	}
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
+    {}
   };
-  //****************************************************************************
-  template <typename Map_,bool Const,int Bi,int Bk>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,3,Bk>:
-    public CMap_extend_iterator<Map_,CMap_dart_iterator_basic_of_orbit_generic
-				<Map_,Const,Bi,3>, Bk>
+#else //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+  template <typename Map_,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
+            int B7,int B8,int B9>
+  class CMap_dart_iterator_basic_of_orbit_generic: 
+    public CMap_extend_iterator
+       <Map_,typename Get_CMap_dart_iterator_basic_of_orbit
+	<Map_,Const,B1,B2,B4,B5,B6,B7,B8,B9>::type, B3>
   {
   public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,3,Bk> Self;
-    typedef CMap_extend_iterator<Map_,CMap_dart_iterator_basic_of_orbit_generic
-				 <Map_,Const,Bi,3>, Bk> Base;
+    typedef typename Get_CMap_dart_iterator_basic_of_orbit
+    <Map_,Const,B1,B2,B3,B4,B5,B6,B7,B8,B9>::type Self;
+
+    typedef CMap_extend_iterator
+    <Map_,typename Get_CMap_dart_iterator_basic_of_orbit
+     <Map_,Const,B1,B2,B4,B5,B6,B7,B8,B9>::type, B3> Base;
 
     typedef typename Base::Dart_handle Dart_handle;
     typedef typename Base::Map Map;
 
-    typedef Tag_true Use_mark;
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
 
   public:
     /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart,
-					     int amark):
+    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart, 
+                                              int amark):
       Base(amap, adart, amark)
-    { CGAL_assertion( Bi<3 && 3<Bk && Bk<=Map::dimension ); }
+    {}
   };
+#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   //****************************************************************************
-  #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+  // TODO? we can optimize the iterators<Bi,Bj,Bk> when
+  // 1<Bi and Bi+2<=Bj and Bj+2<=Bk but there is no real interest...
+  //****************************************************************************
+#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   template<typename Map,int...Beta>
   class CMap_dart_iterator_basic_of_orbit: 
     public CMap_dart_iterator_basic_of_orbit_generic<Map,false,Beta...>
@@ -1211,6 +1097,65 @@ namespace CGAL {
   };
   #endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   //****************************************************************************
+  /* Class CMap_dart_iterator_basic_of_all: to iterate onto all the
+   * darts of the map.
+   */
+  template <typename Map_,bool Const=false>
+  class CMap_dart_iterator_basic_of_all: public CMap_dart_iterator<Map_,Const>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_all Self;
+    typedef CMap_dart_iterator<Map_,Const> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_false Use_mark;
+
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_all(Map& amap):
+      Base(amap, amap.darts().begin())
+    {}
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_all(Map& amap, int /*amark*/):
+      Base(amap, amap.darts().begin())
+    {}
+
+    /// Constructor with a dart in parameter (for end iterator).
+    CMap_dart_iterator_basic_of_all(Map& amap, Dart_handle adart):
+      Base(amap, adart)
+    {}
+    /// Constructor with a dart in parameter (for end iterator).
+    CMap_dart_iterator_basic_of_all(Map& amap, Dart_handle adart,
+                                    int /*amark*/):
+      Base(amap, adart)
+    {}
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(this->cont());
+
+      Base::operator++();
+      if ( (*this) != this->mmap->darts().end())
+      { this->mprev_op = OP_POP; }
+      else
+      {
+        this->set_current_dart(NULL);
+        this->mprev_op = OP_END;
+      }
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+  };
+  //****************************************************************************
+  //***************************CELL*ITERATORS***********************************
+  //****************************************************************************
+  //****************************************************************************
   // i-Cell iterator in combinatorial map of dimension d, i>1
   // i<=Map::dimension+1 (for i==Map::dimension+1, iterate on the connected
   // component)
@@ -1226,6 +1171,8 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    CGAL_static_assertion( i>1 && i<=Map::dimension+1 );
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_cell(Map& amap,
@@ -1234,7 +1181,6 @@ namespace CGAL {
       Base(amap, adart),
       mmark_number(amark)
     {
-      CGAL_assertion( i>=2 && i<=Map::dimension+1 );
       if (adart!=NULL)
 	this->mmap->mark(adart, mmark_number); 
     }
@@ -1254,31 +1200,143 @@ namespace CGAL {
       CGAL_assertion(mmark_number != -1);
       CGAL_assertion(this->cont());
       Dart_handle nd = NULL;
+      
+      for ( unsigned int k=0; k<i; ++k )
+      {
+        if ( this->is_unmarked((*this), k, mmark_number) )
+        {
+          if (nd == NULL)
+          {
+            nd = (*this)->beta(k);
+            CGAL_assertion(nd!=Map::null_dart_handle);
+            this->mmap->mark(nd, mmark_number);
+            this->mprev_op = OP_BETAI;
+          }
+          else
+          {
+            mto_treat.push((*this)->beta(k));
+            this->mmap->mark((*this)->beta(k), mmark_number);
+          }
+        }
+      }
+      for ( unsigned int k=i+1; k<=d; ++k )
+      {
+        if ( this->is_unmarked((*this), k, mmark_number) )
+        {
+          if (nd == NULL)
+          {
+            nd = (*this)->beta(k);
+            CGAL_assertion(nd!=Map::null_dart_handle);
+            this->mmap->mark(nd, mmark_number);
+            this->mprev_op = OP_BETAI;
+          }
+          else
+          {
+            mto_treat.push((*this)->beta(k));
+            this->mmap->mark((*this)->beta(k), mmark_number);
+          }
+        }
+      }
 
-      for ( unsigned int k=0; k<=d; ++k )
-	{
-	  if ( k!=i && this->is_unmarked((*this), k, mmark_number) )
-	    {
-	      if (nd == NULL)
-		{
-		  nd = (*this)->beta(k);
-		  CGAL_assertion(nd!=Map::null_dart_handle);
-		  this->mmap->mark(nd, mmark_number);
-		  this->mprev_op = OP_BETAI;
-		}
-	      else
-		{
-		  mto_treat.push((*this)->beta(k));
-		  this->mmap->mark((*this)->beta(k), mmark_number);
-		}
-	    }
-	}
+      if (nd == NULL)
+      {
+        if (!mto_treat.empty())
+        {
+          nd = mto_treat.front();
+          mto_treat.pop();
+          this->mprev_op = OP_POP;
+        }
+        else
+        {
+          this->mprev_op = OP_END;
+          this->set_current_dart(NULL);
+        }
+      }
+      
+      this->set_current_dart(nd);
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+
+  protected:
+    /// Queue of darts to process.
+    std::queue<Dart_handle> mto_treat;
+
+    /// Index of the used mark.
+    int mmark_number;
+  };
+  //****************************************************************************
+  // i-Cell iterator in combinatorial map of dimension d, i==1.
+  template<typename Map_,int d,bool Const>
+  class CMap_dart_iterator_basic_of_cell<Map_,1,d,Const>:
+    public CMap_dart_iterator<Map_,Const>
+  {
+  public:
+    typedef CMap_dart_iterator_basic_of_cell<Map_,1,d,Const> Self;
+    typedef CMap_dart_iterator<Map_,Const> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+  public:
+    /// Main constructor.
+    CMap_dart_iterator_basic_of_cell(Map& amap,
+                                     Dart_handle adart,
+                                     int amark):
+      Base(amap, adart),
+      mmark_number(amark)
+    {
+      if (adart!=NULL)
+        this->mmap->mark(adart, mmark_number); 
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(mmark_number != -1);
+      Base::rewind();
+      mto_treat = std::queue<Dart_handle>();
+      this->mmap->mark((*this), mmark_number);
+    }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(mmark_number != -1);
+      CGAL_assertion(this->cont());
+
+      Dart_handle nd = NULL;
+      
+      for ( unsigned int k=2; k<=d; ++k )
+      {
+        if ( this->is_unmarked((*this), k, mmark_number) )
+        {
+          if (nd == NULL)
+          {
+            nd = (*this)->beta(k);
+            CGAL_assertion(nd!=Map::null_dart_handle);
+            this->mmap->mark(nd, mmark_number);
+            this->mprev_op = OP_BETAI;
+          }
+          else
+          {
+            mto_treat.push((*this)->beta(k));
+            this->mmap->mark((*this)->beta(k), mmark_number);
+          }
+        }
+      }
 
       if (nd == NULL)
 	{
 	  if (!mto_treat.empty())
 	    {
 	      nd = mto_treat.front();
+	      CGAL_assertion(nd!=Map::null_dart_handle);
 	      mto_treat.pop();
 	      this->mprev_op = OP_POP;
 	    }
@@ -1319,148 +1377,6 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
-  public:
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_cell(Map& amap,
-				     Dart_handle adart,
-				     int amark):
-      Base(amap, adart),
-      mmark_number(amark)
-    { 
-      if (adart!=NULL) this->mmap->mark(adart, mmark_number); 
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(mmark_number != -1);
-      Base::rewind();
-      mto_treat = std::queue<Dart_handle>();
-      this->mmap->mark((*this), mmark_number);
-    }
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      CGAL_assertion(mmark_number != -1);
-      CGAL_assertion(this->cont());
-
-      Dart_handle nd = NULL;
-
-      for ( unsigned int k=2; k<=d; ++k )
-	{
-	  if ( this->is_unmarked2((*this), 0, k, mmark_number) )
-	    {
-	      if (nd == NULL)
-		{
-		  nd = (*this)->beta(0)->beta(k);
-		  CGAL_assertion(nd!=Map::null_dart_handle);
-		  this->mmap->mark(nd, mmark_number);
-		  this->mprev_op = OP_BETA0I;
-		}
-	      else
-		{
-		  mto_treat.push((*this)->beta(0)->beta(k));
-		  this->mmap->mark((*this)->beta(0)->beta(k), mmark_number);
-		}
-	      
-	    }
-	  if ( this->is_unmarked2((*this), k, 1, mmark_number) )
-	    {
-	      if (nd == NULL)
-		{
-		  nd = (*this)->beta(k)->beta(1); 
-		  CGAL_assertion(nd!=Map::null_dart_handle);
-		  this->mmap->mark(nd, mmark_number);
-		  this->mprev_op = OP_BETAI1;
-		}
-	      else
-		{
-		  mto_treat.push((*this)->beta(k)->beta(1));
-		  this->mmap->mark((*this)->beta(k)->beta(1), mmark_number);
-		}
-	    }
-	  for ( unsigned int l=k+1; l<=d; ++l )
-	    {
-	      if ( this->is_unmarked2((*this), k, l, mmark_number) )
-		{
-		  if (nd == NULL)
-		    {
-		      nd = (*this)->beta(k)->beta(l); 
-		      CGAL_assertion(nd!=Map::null_dart_handle);
-		      this->mmap->mark(nd, mmark_number);
-		      this->mprev_op = OP_BETAIJ;
-		    }
-		  else
-		    {
-		      mto_treat.push((*this)->beta(k)->beta(l));
-		      this->mmap->mark((*this)->beta(k)->beta(l), mmark_number);
-		    }
-		}
-	      if ( this->is_unmarked2((*this), l, k, mmark_number) )
-		{
-		  if (nd == NULL)
-		    {
-		      nd = (*this)->beta(l)->beta(k); 
-		      CGAL_assertion(nd!=Map::null_dart_handle);
-		      this->mmap->mark(nd, mmark_number);
-		      this->mprev_op = OP_BETAJI;
-		    }
-		  else
-		    {
-		      mto_treat.push((*this)->beta(l)->beta(k));
-		      this->mmap->mark((*this)->beta(l)->beta(k), mmark_number);
-		    }
-		}
-	    }
-	}
-
-      if (nd == NULL)
-	{
-	  if (!mto_treat.empty())
-	    {
-	      nd = mto_treat.front();
-	      CGAL_assertion(nd!=Map::null_dart_handle);
-	      mto_treat.pop();
-	      this->mprev_op = OP_POP;
-	    }
-	  else
-	    {
-	      this->mprev_op = OP_END;
-	      this->set_current_dart(NULL);
-	    }
-	}
-      
-      this->set_current_dart(nd);
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
-
-  protected:
-    /// Queue of darts to process.
-    std::queue<Dart_handle> mto_treat;
-
-    /// Index of the used mark.
-    int mmark_number;
-  };
-  //****************************************************************************
-  // 1-Cell iterator in combinatorial map of dimension d
-  template<typename Map_,int d,bool Const>
-  class CMap_dart_iterator_basic_of_cell<Map_,1,d,Const>:
-    public CMap_dart_iterator<Map_,Const>
-  {
-  public:
-    typedef CMap_dart_iterator_basic_of_cell<Map_,1,d,Const> Self;
-    typedef CMap_dart_iterator<Map_,Const> Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_true Use_mark;
-
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_cell(Map& amap,
@@ -1488,37 +1404,87 @@ namespace CGAL {
       Dart_handle nd = NULL;
 
       for ( unsigned int k=2; k<=d; ++k )
-	{
-	  if ( this->is_unmarked((*this), k, mmark_number) )
-	    {
-	      if (nd == NULL)
-		{
-		  nd = (*this)->beta(k);
-		  CGAL_assertion(nd!=Map::null_dart_handle);
-		  this->mmap->mark(nd, mmark_number);
-		  this->mprev_op = OP_BETAI;
-		}
-	      else
-		{
-		  mto_treat.push((*this)->beta(k));
-		  this->mmap->mark((*this)->beta(k), mmark_number);
-		}
-	    }
-	}
+      {
+        if ( this->is_unmarked2((*this), 0, k, mmark_number) )
+        {
+          if (nd == NULL)
+          {
+            nd = (*this)->beta(0)->beta(k);
+            CGAL_assertion(nd!=Map::null_dart_handle);
+            this->mmap->mark(nd, mmark_number);
+            this->mprev_op = OP_BETA0I;
+          }
+          else
+          {
+            mto_treat.push((*this)->beta(0)->beta(k));
+            this->mmap->mark((*this)->beta(0)->beta(k), mmark_number);
+          }	      
+        }
+        if ( this->is_unmarked2((*this), k, 1, mmark_number) )
+        {
+          if (nd == NULL)
+          {
+            nd = (*this)->beta(k)->beta(1); 
+            CGAL_assertion(nd!=Map::null_dart_handle);
+            this->mmap->mark(nd, mmark_number);
+            this->mprev_op = OP_BETAI1;
+          }
+          else
+          {
+            mto_treat.push((*this)->beta(k)->beta(1));
+            this->mmap->mark((*this)->beta(k)->beta(1), mmark_number);
+          }
+        }
+        for ( unsigned int l=k+1; l<=d; ++l )
+        {
+          if ( this->is_unmarked2((*this), k, l, mmark_number) )
+          {
+            if (nd == NULL)
+            {
+              nd = (*this)->beta(k)->beta(l); 
+              CGAL_assertion(nd!=Map::null_dart_handle);
+              this->mmap->mark(nd, mmark_number);
+              this->mprev_op = OP_BETAIJ;
+            }
+            else
+            {
+              mto_treat.push((*this)->beta(k)->beta(l));
+              this->mmap->mark((*this)->beta(k)->beta(l), mmark_number);
+            }
+          }
+          if ( this->is_unmarked2((*this), l, k, mmark_number) )
+          {
+            if (nd == NULL)
+            {
+              nd = (*this)->beta(l)->beta(k); 
+              CGAL_assertion(nd!=Map::null_dart_handle);
+              this->mmap->mark(nd, mmark_number);
+              this->mprev_op = OP_BETAJI;
+            }
+            else
+            {
+              mto_treat.push((*this)->beta(l)->beta(k));
+              this->mmap->mark((*this)->beta(l)->beta(k), mmark_number);
+            }
+          }
+        }
+      }
 
       if (nd == NULL)
-	{
-	  if (!mto_treat.empty())
-	    {
-	      nd = mto_treat.front();
-	      mto_treat.pop();
-	      this->mprev_op = OP_POP;
-	    }
-	  else
-	    {
-	      this->mprev_op = OP_END;
-	    }
-	}
+      {
+        if (!mto_treat.empty())
+        {
+          nd = mto_treat.front();
+          CGAL_assertion(nd!=Map::null_dart_handle);
+          mto_treat.pop();
+          this->mprev_op = OP_POP;
+        }
+        else
+        {
+          this->mprev_op = OP_END;
+          this->set_current_dart(NULL);
+        }
+      }
       
       this->set_current_dart(nd);
       return *this;
@@ -1792,227 +1758,9 @@ namespace CGAL {
     /// Boolean: true iff we turn in the first direction (i.e. using beta02).
     bool mfirst_dir;
   };
-  //****************************************************************************
-  /* Class CMap_dart_iterator_basic_of_all: to iterate onto all the
-   * darts of the map.
-   */
-  template <typename Map_,bool Const=false>
-  class CMap_dart_iterator_basic_of_all: public CMap_dart_iterator<Map_,Const>
-  {
-  public:
-    typedef CMap_dart_iterator_basic_of_all Self;
-    typedef CMap_dart_iterator<Map_,Const> Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_false Use_mark;
-
-  public:
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_all(Map& amap):
-      Base(amap, amap.darts().begin())
-    {}
-
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_all(Map& amap, int /*amark*/):
-      Base(amap, amap.darts().begin())
-    {}
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      CGAL_assertion(this->cont());
-
-      Base::operator++();
-      if ( (*this) != this->mmap->darts().end())
-	{ this->mprev_op = OP_POP; }
-      else
-	{
-	  this->set_current_dart(NULL);
-	  this->mprev_op = OP_END;
-	}
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
-  };
-  //**************************************************************************
-  /* Generic nD version. Here we are sure that all the bases classes use mark
-   * and queue.
-   */
-  #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-  template <typename Map_,bool Const,int Bi,int... Beta>
-  class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Beta...>: 
-    public CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Beta...>
-  {
-  public:
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Beta...> Self;
-    typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Beta...> Base;
-
-    typedef typename Base::Dart_handle Dart_handle;
-    typedef typename Base::Map Map;
-
-    typedef Tag_true Use_mark;
-
-  public:
-    /// Main constructor.
-    CMap_dart_iterator_basic_of_orbit_generic(Map& amap, 
-					     Dart_handle adart, 
-					     int amark):
-      Base(amap, adart, amark)
-    { 
-      CGAL_assertion( Bi>=0 && Bi<=Map::dimension );
-
-      if (adart!=NULL)
-	{
-	  if (!adart->is_free(Bi) &&
-	      !this->mmap->is_marked(adart->beta(Bi), this->mmark_number))
-	    this->mto_treat.push(adart->beta(Bi));
-	}
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(this->mmark_number != -1);
-      Base::rewind();
-      if (!(*this)->is_free(Bi) &&
-	  !this->mmap->is_marked((*this)->beta(Bi), 
-				 this->mmark_number))
-	this->mto_treat.push((*this)->beta(Bi));
-    }
-
-    /// Prefix ++ operator.
-    Self& operator++()
-    {
-      CGAL_assertion(this->cont());
-
-      Base::operator++();
-
-      if (this->cont())
-	{
-	  if (!(*this)->is_free(Bi) &&
-	      !this->mmap->is_marked((*this)->beta(Bi), 
-				     this->mmark_number))
-	    this->mto_treat.push((*this)->beta(Bi));
-	}
-      return *this;
-    }
-
-    /// Postfix ++ operator.
-    Self operator++(int)
-    { Self res=*this; operator ++(); return res; }
-  };
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   //****************************************************************************
   //*************************ITERATORS*NON*BASIC*********************************
   //****************************************************************************
-  //* Class CMap_non_basic_iterator allows to transform a basic_iterator onto
-  //* a non basic one, depending if the basic iterator uses mark or not.
-  template <typename Map_,typename Basic_iterator, 
-	    typename Use_mark=typename Basic_iterator::Use_mark>
-  class CMap_non_basic_iterator;
-  //****************************************************************************
-  template <typename Map_,typename Basic_iterator>
-  class CMap_non_basic_iterator<Map_,Basic_iterator,Tag_true>: 
-    public Basic_iterator
-  {
-  public:
-    typedef CMap_non_basic_iterator<Map_,Basic_iterator,Tag_true> Self;
-
-    typedef typename Basic_iterator::Map Map;
-    typedef typename Basic_iterator::Dart_handle Dart_handle;
-
-    /// Main constructor.
-    CMap_non_basic_iterator(Map& amap, Dart_handle adart1):
-      Basic_iterator(amap, adart1, amap.get_new_mark())
-    { CGAL_assertion( Basic_iterator::is_basic_iterator() ); }
-
-    /// Destructor.
-    ~CMap_non_basic_iterator()
-    {
-      if (this->mmark_number != -1)
-	{
-	  unmark_treated_darts();
-	  CGAL_assertion( this->mmap->is_whole_map_unmarked
-			  (this->mmark_number) );
-	  this->mmap->free_mark(this->mmark_number);
-	}
-    }
-
-    /// Copy constructor.
-    CMap_non_basic_iterator(const Self& aiterator):
-      Basic_iterator(aiterator)
-    { this->mmark_number = -1; }
-
-    /// Assignment operator.
-    Self& operator=(const Self& aiterator)
-    {
-      if (this != &aiterator)
-	{
-	  Basic_iterator::operator=(aiterator);
-	  this->mmark_number = -1;
-	}
-      return *this;
-    }
-
-    /// Rewind of the iterator to its beginning.
-    void rewind()
-    {
-      CGAL_assertion(this->mmark_number != -1);
-      unmark_treated_darts();
-      Basic_iterator::rewind();
-    }
-
-    using Basic_iterator::operator++;
-
-    /// Postfix ++ operator.
-    void operator++(int)
-    { operator ++(); }
-
-    /// Return true iff this iterator is basic
-    static bool is_basic_iterator()
-    { return false; }
-
-  protected:
-    /// Unmark all the marked darts during the iterator.
-    void unmark_treated_darts()
-    {
-      CGAL_assertion(this->mmark_number != -1);
-      if (this->mmap->is_whole_map_unmarked(this->mmark_number)) return;
-
-      this->mmap->negate_mark(this->mmark_number);
-
-      if (this->mmap->is_whole_map_unmarked(this->mmark_number)) return;
-
-      Basic_iterator::rewind();
-      while (this->mmap->number_of_unmarked_darts(this->mmark_number) > 0)
-	this->operator++();
-      this->mmap->negate_mark(this->mmark_number);
-      CGAL_assertion(this->mmap->is_whole_map_unmarked(this->mmark_number));
-    }
-  };
-  //****************************************************************************
-  template <typename Map_,typename Basic_iterator>
-  class CMap_non_basic_iterator<Map_,Basic_iterator,Tag_false>: 
-    public Basic_iterator
-  {
-  public:
-    typedef CMap_non_basic_iterator<Map_,Basic_iterator,Tag_false> Self;
-    typedef typename Basic_iterator::Map Map;
-    typedef typename Basic_iterator::Dart_handle Dart_handle;
-
-    /// Main constructor.
-    CMap_non_basic_iterator(Map& amap, Dart_handle adart):
-      Basic_iterator(amap, adart,-1)
-    {}
-    /// Return true iff this iterator is basic
-    static bool is_basic_iterator()
-    { return false; }
-  };
   //****************************************************************************
   #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   template<typename Map_,bool Const,int...Beta>
@@ -2141,6 +1889,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+    
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2149,8 +1900,8 @@ namespace CGAL {
       Base(amap, adart),
       mmark_number(amark)
     {
-      CGAL_assertion( d>=3 && d<=Map::dimension );
-      CGAL_assertion( i>=3 && i<=Map::dimension );
+      CGAL_static_assertion( d>=3 && d<=Map::dimension );
+      CGAL_static_assertion( i>=3 && i<=Map::dimension );
       if (adart!=NULL) this->mmap->mark(adart, mmark_number); 
     }
 
@@ -2258,6 +2009,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2266,7 +2020,7 @@ namespace CGAL {
       Base(amap, adart),
       mmark_number(amark)
     {
-      CGAL_assertion( i>=3 && i<=Map::dimension );
+      CGAL_static_assertion( i>=3 && i<=Map::dimension );
       if (adart!=NULL) this->mmap->mark(adart, mmark_number); 
     }
 
@@ -2371,6 +2125,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2462,6 +2219,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2486,6 +2246,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2577,6 +2340,9 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2601,6 +2367,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2630,6 +2399,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2659,6 +2431,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2688,6 +2463,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2717,6 +2495,9 @@ namespace CGAL {
     
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2746,6 +2527,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2775,6 +2559,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2804,6 +2591,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
@@ -2833,6 +2623,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution(Map& amap,
@@ -2862,6 +2655,9 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
+    /// True iff this iterator is basic
+    typedef Tag_true Basic_iterator;
+
   public:
     /// Main constructor.
     CMap_dart_iterator_basic_of_involution_inv(Map& amap,
diff --git a/Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h
index 5a0b1ef34e0..80b19d9e7b2 100644
--- a/Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h
+++ b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_functors.h
@@ -51,7 +51,7 @@ namespace CGAL {
 		    typename Map::Dart_const_handle adart1,
 		    typename Map::Dart_const_handle adart2)
     {
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
       CGAL_assertion(adart1!=NULL && adart2!=NULL);
       
       if ( !adart1->is_free(i) || !adart2->is_free(i) || adart1==adart2 )
@@ -144,7 +144,7 @@ namespace CGAL {
     static void run(Map& amap,typename Map::Dart_handle adart1,
 		    typename Map::Dart_handle adart2)
     {      
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
       CGAL_assertion( (is_sewable_functor<Map,i>::run(amap,adart1,adart2)) );
 
       CMap_dart_iterator_of_involution<Map,i>     I1(amap, adart1);
@@ -205,7 +205,7 @@ namespace CGAL {
     static void run(Map& amap,typename Map::Dart_handle adart1,
 		    typename Map::Dart_handle adart2)
     {      
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
       CGAL_assertion( (is_sewable_functor<Map,i>::run(amap,adart1,adart2)) );
       
       CMap_dart_iterator_of_involution<Map,i>     I1(amap, adart1);
@@ -312,7 +312,7 @@ namespace CGAL {
     static void run(Map& amap,typename Map::Dart_handle adart)
     {      
       CGAL_assertion( adart!=NULL && !adart->is_free(i) );
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
 
       CMap_dart_iterator_of_involution<Map,i> it(amap, adart);
       while ( it.cont() )
@@ -372,7 +372,7 @@ namespace CGAL {
   struct unsew_functor{
     static void run(Map& amap,typename Map::Dart_handle adart)
     {      
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
       CGAL_assertion( adart!=NULL && !adart->is_free(i) );
 
       std::stack<Couple_dart_and_dim<typename Map::Dart_handle> > todegroup;
@@ -478,7 +478,7 @@ namespace CGAL {
 		    typename Map::Dart_handle adart2)
     {      
       CGAL_assertion(adart1 != NULL && adart2 != NULL && adart1!=adart2);
-      CGAL_assertion( i>=2 && i<=Map::dimension );
+      CGAL_static_assertion( i>=2 && i<=Map::dimension );
       adart1->basic_link_beta(adart2, i);
       adart2->basic_link_beta(adart1, i);
     }
@@ -514,7 +514,7 @@ namespace CGAL {
     static void run(Map&,typename Map::Dart_handle adart)
     {      
       CGAL_assertion(adart != NULL && !adart->is_free(i));
-      CGAL_assertion(2<=i && i<=Map::dimension);
+      CGAL_static_assertion(2<=i && i<=Map::dimension);
       adart->beta(i)->unlink_beta(i);
       adart->unlink_beta(i);
     }
@@ -889,7 +889,7 @@ namespace CGAL {
 		      typename CMap::Dart_handle adart2)
       {      
 	CGAL_assertion(adart1 != NULL && adart2 != NULL && adart1!=adart2 );
-	CGAL_assertion( 2<=i && i<=CMap::dimension );
+	CGAL_static_assertion( 2<=i && i<=CMap::dimension );
 	adart1->basic_link_beta(adart2, i);
 	adart2->basic_link_beta(adart1, i);
 	CMap::Helper::template Foreach_enabled_attributes
diff --git a/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h
index fee79ded604..30c90f9b84d 100644
--- a/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h
+++ b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h
@@ -23,1439 +23,299 @@
 #include <CGAL/tuple.h>
 #include <CGAL/Compact_container.h>
 #include <iostream>
-#include <CGAL/assertions.h>
-
-#ifdef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits.hpp>
-#endif
-
 
 namespace CGAL 
 {
-  // struct Disabled {}; // If we want to use CGAL::Disabled for disabled attributes
-  // typedef CGAL::Void Disabled; 
-  // typedef void Disabled; // If we wand to use void, does not compile on windows
-
   namespace internal
   {    
-	  // There is a problem on windows to handle tuple containing void. To solve this, we
-	  // transform such a tuple in tuple containing Disabled.
-	template<typename T>
-	struct Convert_void
-	{ typedef T type; };
-
-	template<>
-	struct Convert_void<void>
-	{ typedef CGAL::Void type; };
-
-	#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-	template<typename ... Items>
-	struct Convert_tuple_with_void;
+    // There is a problem on windows to handle tuple containing void.
+    // To solve this, we transform such a tuple in tuple containing Disabled.
+    template<typename T>
+    struct Convert_void
+    { typedef T type; };
     
-	template<typename ... Items>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<Items...> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<Items>::type... > type;
-	};
-    
-        template<typename ... T>
-        struct My_length;    
-        template<typename T1, typename ... T>
-	struct My_length<CGAL::cpp0x::tuple<T1, T...> >
-	{
-	  static const int value = My_length<CGAL::cpp0x::tuple<T...> >::value + 1;
-	};
-    
-        template<>
-	struct My_length<CGAL::cpp0x::tuple<> >
-	{
-	  static const int value = 0;
-	};
-    
-
-#else //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-	template <class T1>
-	struct Convert_tuple_with_void;
-
-	template <>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<> >
-	{
-	typedef CGAL::cpp0x::tuple<> type;
-	};
-	template <class T1>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type > type;
-	};
-	template <class T1, class T2>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type> type;
-	};
-	template <class T1, class T2, class T3>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4, class T5>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4, T5> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type,
-			     typename Convert_void<T5>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type,
-			     typename Convert_void<T5>::type,
-			     typename Convert_void<T6>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type,
-			     typename Convert_void<T5>::type,
-			     typename Convert_void<T6>::type,
-			     typename Convert_void<T7>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
-			  class T8>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type,
-			     typename Convert_void<T5>::type,
-			     typename Convert_void<T6>::type,
-			     typename Convert_void<T7>::type,
-			     typename Convert_void<T8>::type> type;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
-			  class T8, class T9>
-	struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >
-	{
-	typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
-			     typename Convert_void<T2>::type,
-			     typename Convert_void<T3>::type,
-			     typename Convert_void<T4>::type,
-			     typename Convert_void<T5>::type,
-			     typename Convert_void<T6>::type,
-			     typename Convert_void<T7>::type,
-			     typename Convert_void<T8>::type,
-			     typename Convert_void<T9>::type> type;
-	};
-	template <class T>
-	struct My_length;
-
-	template <>
-	struct My_length<CGAL::cpp0x::tuple<> >
-	{
-	  static const int value = 0;
-	};
-	template <class T1>
-	struct My_length<CGAL::cpp0x::tuple<T1> >
-	{
-	  static const int value = 1;
-	};
-	template <class T1, class T2>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2> >
-	{
-	  static const int value = 2;
-	};
-	template <class T1, class T2, class T3>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3> >
-	{
-	  static const int value = 3;
-	};
-	template <class T1, class T2, class T3, class T4>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4> >
-	{
-	  static const int value = 4;
-	};
-	template <class T1, class T2, class T3, class T4, class T5>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4, T5> >
-	{
-	  static const int value = 5;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
-	{
-	  static const int value = 6;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
-	{
-	  static const int value = 7;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
-			  class T8>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
-	{
-	  static const int value = 8;
-	};
-	template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
-			  class T8, class T9>
-	struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >
-	{
-	  static const int value = 9;
-	};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+    template<>
+    struct Convert_void<void>
+    { typedef CGAL::Void type; };
     
 #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-//count the number of time a given type is present in a tuple
-template<class Type,class Tuple>
-struct Number_of_type_in_tuple;
-  
-template<class Type,typename ... Items>
-struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Type,Items...> >{
-  static const int value=Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Items...> >::value+1;
-};
+    // Convert a tuple in a same tuple where each void type was replaced into
+    // CGAL::Void.
+    template<typename ... Items>
+    struct Convert_tuple_with_void;    
+    template<typename ... Items>
+    struct Convert_tuple_with_void<CGAL::cpp0x::tuple<Items...> >
+    {
+      typedef CGAL::cpp0x::tuple<typename Convert_void<Items>::type... > type;
+    };
 
-template<class Type,class Other, typename ... Items>
-struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Other,Items...> >{
-  static const int value=Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Items...> >::value;
-};
+    // Length of a variadic template
+    template<typename ... T>
+    struct My_length;    
+    template<typename T1, typename ... T>
+    struct My_length<CGAL::cpp0x::tuple<T1, T...> >
+    {
+      static const int value = My_length<CGAL::cpp0x::tuple<T...> >::value + 1;
+    };    
+    template<>
+    struct My_length<CGAL::cpp0x::tuple<> >
+    {
+      static const int value = 0;
+    };
 
-template<class Type>
-struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<> >{
-  static const int value=0;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+    //count the number of time a given type is present in a tuple
+    template<class Type,class Tuple>
+    struct Number_of_type_in_tuple;    
+    template<class Type,typename ... Items>
+    struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Type,Items...> >{
+      static const int value=Number_of_type_in_tuple
+	<Type,CGAL::cpp0x::tuple<Items...> >::value+1;
+    };
+    template<class Type,class Other, typename ... Items>
+    struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<Other,Items...> >{
+      static const int value=Number_of_type_in_tuple
+	<Type,CGAL::cpp0x::tuple<Items...> >::value;
+    };
+    template<class Type>
+    struct Number_of_type_in_tuple<Type,CGAL::cpp0x::tuple<> >{
+      static const int value=0;
+    };
 
-//count the number of different types from Type is present in a tuple
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template<class Type, class Tuple>
-struct Number_of_different_type_in_tuple;
-  
-template<class Type, typename Other, typename ... Items>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<Other, Items...> >
-{
-  static const int value=Number_of_different_type_in_tuple<Type,
-         CGAL::cpp0x::tuple<Items...> >::value+1;
-};
+    //count the number of different types from Type is present in a tuple
+    template<class Type, class Tuple>
+    struct Number_of_different_type_in_tuple;    
+    template<class Type, typename Other, typename ... Items>
+    struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+					     <Other, Items...> >
+    {
+      static const int value=Number_of_different_type_in_tuple
+	<Type,CGAL::cpp0x::tuple<Items...> >::value+1;
+    };
+    template<class Type, typename ... Items>
+    struct Number_of_different_type_in_tuple<Type, CGAL::cpp0x::tuple
+					     <Type,Items...> >
+    {
+      static const int value=Number_of_different_type_in_tuple
+	<Type,CGAL::cpp0x::tuple<Items...> >::value;
+    };
+    template<class Type>
+    struct Number_of_different_type_in_tuple<Type, CGAL::cpp0x::tuple<> >
+    {
+      static const int value=0;
+    };
 
-template<class Type, typename ... Items>
-struct Number_of_different_type_in_tuple<Type, CGAL::cpp0x::tuple<Type,Items...> >
-{
-  static const int value=Number_of_different_type_in_tuple<Type,
-      CGAL::cpp0x::tuple<Items...> >::value;
-};
+    //count the number of time a given type have been found
+    //within a tuple, until reaching position the k'th type of the tuple.
+    //dim is the total size of the tuple
+    template <class Type,int k,class T,
+	      int dim=CGAL::internal::My_length<T>::value-1>
+    struct Nb_type_in_tuple_up_to_k;
+    
+    template <class Type,int dim,int k,class T1,class ... T>
+    struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T...>,dim>
+    {
+      static const int pos= Nb_type_in_tuple_up_to_k
+	<Type,k,CGAL::cpp0x::tuple<T...>,dim>::pos - 1;
+      
+      static const int value =
+	( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? 0:-dim-1 )
+	:  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 1:0 )
+			   + Nb_type_in_tuple_up_to_k
+			   <Type,k,CGAL::cpp0x::tuple
+			    <T...>,dim >::value)
+	     :0
+	     );
+    };
+    
+    template <class Type,int dim,int k,class T1>
+    struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1>,dim >
+    {
+      static const int pos=dim;
+      static const int value=(pos==k?
+			      (boost::is_same<T1,Type>::value?0:-dim-1) :
+			      0);
+    };
 
-template<class Type>
-struct Number_of_different_type_in_tuple<Type, CGAL::cpp0x::tuple<> >
-{
-  static const int value=0;
-};
+    //count the number of time a type different from Type have been found
+    //within a tuple, until reaching position the k'th type of the tuple.
+    //dim is the total size of the tuple
+    template <class Type, int k,class T,
+	      int dim=CGAL::internal::My_length<T>::value-1>
+    struct Nb_type_different_in_tuple_up_to_k;
+    
+    template <class Type,int dim,int k,class T1,class ... T>
+    struct Nb_type_different_in_tuple_up_to_k<Type,k,
+					      CGAL::cpp0x::tuple<T1,T...>,dim>
+    {
+      static const int pos = Nb_type_different_in_tuple_up_to_k
+	<Type,k,CGAL::cpp0x::tuple<T...>,dim >::pos - 1;
+      
+      static const int value =
+	( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+	:  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+			   + Nb_type_different_in_tuple_up_to_k
+			   <Type,k,CGAL::cpp0x::tuple<T...>,dim >::value)
+	     :0
+	     );
+    };
+
+    template <class Type,int dim,int k,class T1>
+    struct Nb_type_different_in_tuple_up_to_k<Type,k,
+					      CGAL::cpp0x::tuple<T1>,dim >
+    {
+      static const int pos=dim;
+      static const int value=(pos==k?
+			      (boost::is_same<T1,Type>::value?-dim-1:0) :
+			      0);
+    };
+
+    //Convert a tuple of T... to a tuple of Functor<T>::type...
+    template <template <class D> class Functor,class T>
+    struct Tuple_converter;
+    template <template <class D> class Functor,class ...T>
+    struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T...> >{
+      typedef CGAL::cpp0x::tuple<typename Functor<T>::type... > type;
+    };
+
+    // To scan a given tuple, and keep only type different from Type
+    // to build the tuple Attribute_type.
+    template <class Type,class Res, class Tuple=CGAL::cpp0x::tuple<> >
+    struct Keep_type_different_of;
+    
+    template < class Type,class ... Res >
+    struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<>,
+				  CGAL::cpp0x::tuple<Res...> >
+    {
+      typedef CGAL::cpp0x::tuple<Res...> type;
+    };
+
+    template < class Type,class ... T, class ... Res >
+    struct Keep_type_different_of<Type,
+				  CGAL::cpp0x::tuple<Type,T ...>,
+				  CGAL::cpp0x::tuple<Res...> >
+    {
+      typedef typename Keep_type_different_of
+      <Type,CGAL::cpp0x::tuple<T ...>,CGAL::cpp0x::tuple<Res...> >::type type;
+    };
+
+    template < class Type, class Other, class ... T, class ... Res >
+    struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<Other,T...>, 
+				  CGAL::cpp0x::tuple<Res...> >
+    {
+      typedef typename Keep_type_different_of
+      <Type, CGAL::cpp0x::tuple<T...>,
+       CGAL::cpp0x::tuple<Res...,Other> >::type type;
+    };
+
+    //Helper class to statically call a functor
+    // for (int i=n;i>=0;--i) Functor::run<i>(....)
+    //Usage:
+    //
+    // struct Functor{
+    //   template <int n>
+    //   static void run(){std::cout << n << std::endl;}
+    // };
+    // 
+    // Foreach_static<Functor,5>::run();
+    //
+    template <class Functor,int n>
+    struct Foreach_static{
+      template <class  ... T>
+      static void run(const T& ... t){
+	Functor:: template run<n>(t...);
+	Foreach_static<Functor,n-1>::run(t...);
+      }
+    };
+    
+    template <class Functor>
+    struct Foreach_static<Functor,0>{
+      template <class  ... T>
+      static void run(const T& ... t)
+      {
+	Functor:: template run<0>( t... );
+      }
+    };
+
+    //Helper function that is calling
+    //Functor if TAG is different from Void
+    template <class Functor,int n,class Type>
+    struct Conditionnal_run{
+      template <class ... T>
+      static void run(const T& ... t){
+	Functor:: template run<n>(t...);
+      }
+    };
+    
+    template <class Functor,int n>
+    struct Conditionnal_run<Functor,n,Void>
+    {
+      template <class ... T>
+      static void run(T...){}
+    };
+
+    //Same as Foreach_static excepted that Functor
+    //is called for case k only if the k'th type in the tuple
+    //is different from Void. Note that to the converse of Foreach_static
+    //Functor are called from n =0 to k
+    template <class Functor,class T,int n=0>
+    struct Foreach_static_restricted;
+    
+    template <class Functor,class Head, class ... Items,int n>
+    struct Foreach_static_restricted<Functor,
+				     CGAL::cpp0x::tuple<Head,Items...>,n>
+    {
+      template <class  ... T>
+      static void run(const T& ... t){
+        Conditionnal_run<Functor,n,Head>::run(t...);
+        Foreach_static_restricted
+          <Functor,CGAL::cpp0x::tuple<Items...>,n+1>::run(t...);
+      }
+    };
+    
+    template <class Functor,int n>
+    struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n>{
+      template <class  ... T>
+      static void run(const T& ... ){}
+    };
 #else
-template<class Type, class Tuple>
-struct Number_of_different_type_in_tuple;
-
-template <class Type>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<> >
-{
-  static const int value=0;
-};
-
-template <class Type, class T1>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1> >
-{
-  static const int value=boost::is_same<Type,T1>::value?0:1;
-};
-
-template <class Type, class T1,class T2>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2> >::value;
-};
-
-template <class Type, class T1,class T2,class T3>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4,class T5>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4,class T5,class T6>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8> >::value;
-};
-
-template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >
-{
-  static const int value= (boost::is_same<Type,T1>::value?0:1) + Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9> >::value;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-//count the number of time a given type have been found
-//within a tuple, until reaching position the k'th type of the tuple.
-//dim is the total size of the tuple
-template <class Type,int k,class T,int dim=CGAL::internal::My_length<T>::value-1>
-struct Nb_type_in_tuple_up_to_k;
-
-template <class Type,int dim,int k,class T1,class ... T>
-struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T...>,dim>{
-  static const int pos= Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T...>,dim>::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? 0:-dim-1 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 1:0 )
-                                     + Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T...>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1>
-struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1>,dim >{
-  static const int pos=dim;
-  static const int value= pos==k? boost::is_same<T1,Type>::value?0:-dim-1 : 0;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//count the number of time a type different from Type have been found
-//within a tuple, until reaching position the k'th type of the tuple.
-//dim is the total size of the tuple
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Type, int k,class T,int dim=CGAL::internal::My_length<T>::value-1>
-struct Nb_type_different_in_tuple_up_to_k;
-
-template <class Type,int dim,int k,class T1,class ... T>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T...>,dim>{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T...>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T...>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1>,dim >{
-  static const int pos=dim;
-  static const int value= pos==k? boost::is_same<T1,Type>::value?-dim-1:0 : 0;
-};
-#else
-template <class Type, int k,class T,int dim=CGAL::internal::My_length<T>::value-1>
-struct Nb_type_different_in_tuple_up_to_k;
-
-template <class Type,int dim,int k,class T1>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1>,dim >{
-  static const int pos=dim;
-  static const int value= pos==k? boost::is_same<T1,Type>::value?-dim-1:0 : 0;
-};
-
-template <class Type,int dim,int k,class T1,class T2>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3>,dim >::value)
-                               :0
-                   );
-};
-
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4,class T5>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4,T5>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4,class T5,class T6>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4,T5,T6>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,dim >::value)
-                               :0
-                   );
-};
-
-template <class Type,int dim,int k,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>,dim >{
-  static const int pos= 
-    Nb_type_different_in_tuple_up_to_k<Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,dim >::pos - 1;
-
-  static const int value =
-    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
-                :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
-		   + Nb_type_different_in_tuple_up_to_k<Type,k,
-                                   CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,dim >::value)
-                               :0
-                   );
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//Convert a tuple of T... to a tuple of Functor<T>::type...
-template <template <class D> class Functor,class T>
-struct Tuple_converter;
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <template <class D> class Functor,class ...T>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T...> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T>::type... > type;
-};
-#else
-template <template <class D> class Functor>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<> >{
-  typedef CGAL::cpp0x::tuple<> type;
-};
-
-template <template <class D> class Functor,class T1>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type > type;
-};
-
-template <template <class D> class Functor,class T1,class T2>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type > type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type , typename Functor<T3>::type > type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type> type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4,class T5>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type, typename Functor<T5>::type> type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4,class T5,class T6>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type, typename Functor<T5>::type, typename Functor<T6>::type> type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type, typename Functor<T5>::type, typename Functor<T6>::type, typename Functor<T7>::type> type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type, typename Functor<T5>::type, typename Functor<T6>::type, typename Functor<T7>::type, typename Functor<T8>::type> type;
-};
-
-template <template <class D> class Functor,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >{
-  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type, typename Functor<T2>::type, typename Functor<T3>::type, typename Functor<T4>::type, typename Functor<T5>::type, typename Functor<T6>::type, typename Functor<T7>::type, typename Functor<T8>::type, typename Functor<T9>::type> type;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//Apply a functor to each element of a tuple
-template<class Functor,class Tuple,int pos=CGAL::internal::My_length<Tuple>::value-1>
-struct Apply_functor_to_each_tuple_element
-{
-  static void run(Tuple& t){
-    Functor() ( CGAL::cpp0x::get<pos>(t) );
-    Apply_functor_to_each_tuple_element<Functor,Tuple,pos-1>::run(t);
-  }
-};
-
-template<class Functor,class Tuple>
-struct Apply_functor_to_each_tuple_element<Functor,Tuple,-1>
-{
-  static void run(Tuple&){}
-};
-
-struct Clear_functor
-{
-  template<class T>
-  void operator()(T&t)
-  { t.clear(); }
-};
-
-struct Clear_all
-{
-  template<class Tuple>
-  static void run(Tuple& t)
-  {
-    Apply_functor_to_each_tuple_element<Clear_functor,Tuple>::run(t);    
-  }
-};
-
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-//if the number of elements in T is lower than size,
-//append void
-template <int size,class Tuple,int remaining = size - CGAL::internal::My_length<Tuple>::value>
-struct Fill_tag_false;
-
-template <int size, class ... T,int remaining>
-struct Fill_tag_false<size,CGAL::cpp0x::tuple<T...>,remaining>
-{
-  typedef typename Fill_tag_false<size,CGAL::cpp0x::tuple<T...,Tag_false>,remaining - 1>::type type;
-};
-
-template <int size,class ... T>
-struct Fill_tag_false<size,CGAL::cpp0x::tuple<T...>,0 >
-{
-  typedef CGAL::cpp0x::tuple<T...> type;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//if the number of elements in T is lower than size,
-//append Type
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Type,int size, class Tuple, 
-	  int remaining = size - CGAL::internal::My_length<Tuple>::value>
-struct Fill_type;
-
-template <class Type, int size, class ... T, int remaining>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T...>,remaining>
-{
-  typedef typename Fill_type<Type,size,
-			     CGAL::cpp0x::tuple<T...,Void>,remaining - 1>::type type;
-};
-
-template < class Type,int size, class ... T >
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T...>,0 >
-{
-  typedef CGAL::cpp0x::tuple<T...> type;
-};
-
-template < int size, class Tuple >
-struct Fill_disabled
-{
-  typedef typename Fill_type<Void,size,Tuple>::type type;
-};
-#else
-template <class Type,int size, class Tuple>
-struct Fill_type{
-  typedef void type;
-   CGAL_static_assertion(size < 10);
-};
-
-template <class Type,int size>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<> >{
-  typedef typename boost::mpl::if_c<size==0,CGAL::cpp0x::tuple<>,typename Fill_type<Type,size,CGAL::cpp0x::tuple<Type> >::type >::type type;
-};
-
-template <class Type,int size, class T1>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1> >{
-  typedef typename boost::mpl::if_c<size==1,CGAL::cpp0x::tuple<T1>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2> >{
-  typedef typename boost::mpl::if_c<size==2,CGAL::cpp0x::tuple<T1,T2>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3> >{
-  typedef typename boost::mpl::if_c<size==3,CGAL::cpp0x::tuple<T1,T2,T3>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4> >{
-  typedef typename boost::mpl::if_c<size==4,CGAL::cpp0x::tuple<T1,T2,T3,T4>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4,class T5>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >{
-  typedef typename boost::mpl::if_c<size==5,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4,class T5,class T6>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >{
-  typedef typename boost::mpl::if_c<size==6,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >{
-  typedef typename boost::mpl::if_c<size==7,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >{
-  typedef typename boost::mpl::if_c<size==8,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,Type> >::type  >::type type;
-};
-
-template <class Type,int size, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >{
-  typedef typename boost::mpl::if_c<size==9,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>, typename Fill_type<Type,size,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,Type> >::type  >::type type;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-
-
-// To scan a given tuple, and keep only type different from Type
-// to build the tuple Attribute_type.
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Type,class Res, class Tuple=CGAL::cpp0x::tuple<> >
-struct Keep_type_different_of;
-
-template < class Type,class ... Res >
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<>, CGAL::cpp0x::tuple<Res...> >
-{
-  typedef CGAL::cpp0x::tuple<Res...> type;
-};
-
-template < class Type,class ... T, class ... Res >
-struct Keep_type_different_of<Type,
-		    CGAL::cpp0x::tuple<Type,T ...>, CGAL::cpp0x::tuple<Res...> >
-{  
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T ...>,
-    CGAL::cpp0x::tuple<Res...> >::type type;
-};
-
-template < class Type, class Other, class ... T, class ... Res >
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<Other,T...>, 
-				       CGAL::cpp0x::tuple<Res...> >
-{
-  typedef typename  Keep_type_different_of<Type, CGAL::cpp0x::tuple<T...>,
-    CGAL::cpp0x::tuple<Res...,Other> >::type type;
-};
-#else
-template <class Type,class Tuple>
-struct Append_to_tuple;
-  
-template <class Type>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<> >{  typedef CGAL::cpp0x::tuple<Type> type; };
-
-template <class Type,class T1>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1> >{  typedef CGAL::cpp0x::tuple<T1,Type> type; };
-
-template <class Type,class T1,class T2>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2> >{  typedef CGAL::cpp0x::tuple<T1,T2,Type> type; };
-
-template <class Type,class T1,class T2,class T3>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4,class T5>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4,class T5,class T6>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,Type> type; };
-
-template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >{  typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,Type> type; };
-
-template <class Type,class Tuple,class Result=CGAL::cpp0x::tuple<> >
-struct Keep_type_different_of;
-
-template <class Type,class Result>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<>,Result> {
-  typedef Result type;
-};  
-  
-template <class Type,class T1,class Result>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type type;
-};
-
-template <class Type,class Result,class T1,class T2>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4,class T5>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4,class T5,class T6>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8>,Result> {
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,New_result>::type type;
-};
-
-template <class Type,class Result,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>,Result>{
-  typedef typename boost::mpl::if_< typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple<T1,Result>::type  >::type New_result;
-  typedef typename Keep_type_different_of<Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,New_result>::type type;
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-
-//Helper class to statically call a functor
-// for (int i=n;i>=0;--i) Functor::run<i>(....)
-//Usage:
-//
-// struct Functor{
-//   template <int n>
-//   static void run(){std::cout << n << std::endl;}
-// };
-// 
-// Foreach_static<Functor,5>::run();
-//
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Functor,int n>
-struct Foreach_static{
-  template <class  ... T>
-  static void run(const T& ... t){
-    Functor:: template run<n>(t...);
-    Foreach_static<Functor,n-1>::run(t...);
-  }
-};
-
-template <class Functor>
-struct Foreach_static<Functor,0>{
-  template <class  ... T>
-  static void run(const T& ... t)
-  {
-    Functor:: template run<0>( t... );
-  }
-};
-#else
-template <class Functor,int n>
-struct Foreach_static
-{
-  static void run() 
-  {
-    Functor:: template run<n>();
-    Foreach_static<Functor,n-1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1) 
-  {
-    Functor:: template run<n>(t1);
-    Foreach_static<Functor,n-1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2) 
-  {
-    Functor:: template run<n>(t1,t2);
-    Foreach_static<Functor,n-1>::run(t1,t2);
-  }
-  
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3)
-  {
-    Functor:: template run<n>(t1,t2,t3);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3);
-  }
-  
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5,class T6>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8,const T9& t9)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
-    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
-  }
-};
-
-
-template <class Functor>
-struct Foreach_static<Functor,0>
-{
-  static void run() 
-  {
-    Functor:: template run<0>();
-  }
-
-  template<class T1>
-  static void run(const T1& t1) 
-  {
-    Functor:: template run<0>(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2) 
-  {
-    Functor:: template run<0>(t1,t2);
-  }
-  
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3)
-  {
-    Functor:: template run<0>(t1,t2,t3);
-  }
-  
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4,t5);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5,class T6>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4,t5,t6);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7,t8);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8,const T9& t9)
-  {
-    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
-  }  
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//Helper function that is calling
-//Functor if TAG is different from Void
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Functor,int n,class Type>
-struct Conditionnal_run{
-  template <class ... T>
-  static void run(const T& ... t){
-    Functor:: template run<n>(t...);
-  }
-};
-
-template <class Functor,int n>
-struct Conditionnal_run<Functor,n,Void>
-{
-  template <class ... T>
-  static void run(T...){}
-};
-#else
-template <class Functor,int n,class Type>
-struct Conditionnal_run{
-  static void run() 
-  {
-    Functor:: template run<n>();
-  }
-
-  template<class T1>
-  static void run(const T1& t1) 
-  {
-    Functor:: template run<n>(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2) 
-  {
-    Functor:: template run<n>(t1,t2);
-  }
-  
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3)
-  {
-    Functor:: template run<n>(t1,t2,t3);
-  }
-  
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5);
-  }
-  
-  template<class T1,class T2,class T3,class T4,class T5,class T6>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8);
-  }
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8,const T9& t9)
-  {
-    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
-  }  
-};
-
-template <class Functor,int n>
-struct Conditionnal_run<Functor,n,Void>
-{
-  static void run(){}
-
-  template<class T1>
-  static void run(const T1&){}
-
-  template<class T1,class T2>
-  static void run(const T1&,const T2&){}
-  
-  template<class T1,class T2,class T3>
-  static void run(const T1&,const T2&,const T3&){}
-  
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1&,const T2&,const T3&,const T4&){}
-  
-  template<class T1,class T2,class T3,class T4,class T5>
-  static void run(const T1&,const T2&,const T3&,const T4&,const T5&){}
-  
-  template<class T1,class T2,class T3,class T4,class T5,class T6>
-  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&){}
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,const T7&){}
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,const T7&,const T8&){}
-
-  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,const T7&,const T8&,const T9&){}
-};
-#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
-//Same as Foreach_static excepted that Functor
-//is called for case k only if the k'th type in the tuple
-//is different from Void. Note that to the converse of Foreach_static
-//Functor are called from n =0 to k
-#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-template <class Functor,class T,int n=0>
-struct Foreach_static_restricted;
-
-template <class Functor,class Head, class ... Items,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<Head,Items...>,n>
-{
-  template <class  ... T>
-  static void run(const T& ... t){
-    Conditionnal_run<Functor,n,Head>::run(t...);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<Items...>,n+1>::run(t...);
-  }
-};
-
-template <class Functor,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n>{
-  template <class  ... T>
-  static void run(const T& ... ){}
-};
-#else
-template <class Functor,class T,int n=0>
-struct Foreach_static_restricted;
-
-template <class Functor,class TT1,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,class TT6,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,class TT6,class TT7,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6,TT7>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,class TT6,class TT7,class TT8,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,class TT6,class TT7,class TT8,class TT9,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n>
-{
-  static void run(){
-    Conditionnal_run<Functor,n,TT1>::run();
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run();
-  }
-
-  template<class T1>
-  static void run(const T1& t1){
-    Conditionnal_run<Functor,n,TT1>::run(t1);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run(t1);
-  }
-
-  template<class T1,class T2>
-  static void run(const T1& t1,const T2& t2){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run(t1,t2);
-  }
-
-  template<class T1,class T2,class T3>
-  static void run(const T1& t1,const T2& t2,const T3& t3){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run(t1,t2,t3);
-  }
-
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
-    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
-    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run(t1,t2,t3,t4);
-  }
-};
-
-
-template <class Functor,int n>
-struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n>{
-  static void run(){}
-
-  template<class T1>
-  static void run(const T1&){}
-
-  template<class T1,class T2>
-  static void run(const T1&,const T2&){}
-  
-  template<class T1,class T2,class T3>
-  static void run(const T1&,const T2&,const T3&){}
-  
-  template<class T1,class T2,class T3,class T4>
-  static void run(const T1&,const T2&,const T3&,const T4&){}
-};
+// Definitions of structs are moved to another file.
+#include <CGAL/internal/Combinatorial_map_utility_novariadic.h>
 #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
 
+    //Apply a functor to each element of a tuple
+    template<class Functor,class Tuple,
+	     int pos=CGAL::internal::My_length<Tuple>::value-1>
+    struct Apply_functor_to_each_tuple_element
+    {
+      static void run(Tuple& t){
+	Functor() ( CGAL::cpp0x::get<pos>(t) );
+	Apply_functor_to_each_tuple_element<Functor,Tuple,pos-1>::run(t);
+      }
+    };
+    
+    template<class Functor,class Tuple>
+    struct Apply_functor_to_each_tuple_element<Functor,Tuple,-1>
+    {
+      static void run(Tuple&){}
+    };
+    
+    struct Clear_functor
+    {
+      template<class T>
+      void operator()(T&t)
+      { t.clear(); }
+    };
+    
+    struct Clear_all
+    {
+      template<class Tuple>
+      static void run(Tuple& t)
+      {
+	Apply_functor_to_each_tuple_element<Clear_functor,Tuple>::run(t);    
+      }
+    };    
+
+// Helper class, templated by a given combinatorial map.
 template <class CMap>
 struct Combinatorial_map_helper
 {
@@ -1478,16 +338,19 @@ struct Combinatorial_map_helper
   template <class T>
   struct Add_compact_container_const_iterator{
     typedef typename CMap::Alloc::template rebind<T>::other Attr_allocator;
-    typedef typename CGAL::Compact_container<T,Attr_allocator>::const_iterator type;
+    typedef typename
+    CGAL::Compact_container<T,Attr_allocator>::const_iterator type;
   };
 
   // All the attributes (with CGAL::Void)
-  typedef typename internal::Convert_tuple_with_void<typename CMap::Attributes>::type Attributes;
+  typedef typename CGAL::internal::Convert_tuple_with_void
+  <typename CMap::Attributes>::type Attributes;
+
   // typedef typename CMap::Attributes Attributes;
 
   // Enabled attributes (without CGAL::Void)
-  typedef typename Keep_type_different_of<Void,
-    Attributes>::type Enabled_attributes;
+  typedef typename CGAL::internal::Keep_type_different_of
+  <CGAL::Void,Attributes>::type Enabled_attributes;
 
   // Number of all attributes
   /*  Does not compile on windows !!
@@ -1504,14 +367,17 @@ struct Combinatorial_map_helper
   { static const int value=
         Nb_type_different_in_tuple_up_to_k<Void,d,Attributes>::value; };  
 
-  // All these type contains as many entries than the number of enabled attributes
-  typedef typename Tuple_converter< Add_compact_container,
-				    Enabled_attributes >::type Attribute_containers; 
+  // All these type contains as many entries than the number of
+  // enabled attributes
+  typedef typename Tuple_converter
+  < Add_compact_container, Enabled_attributes >::type Attribute_containers; 
 
   typedef typename Tuple_converter< Add_compact_container_iterator,
-				    Enabled_attributes >::type  Attribute_iterators; 
+				    Enabled_attributes >::type
+  Attribute_iterators; 
   typedef typename Tuple_converter< Add_compact_container_const_iterator,
-				    Enabled_attributes >::type  Attribute_const_iterators; 
+				    Enabled_attributes >::type
+  Attribute_const_iterators; 
 
   typedef Attribute_containers      Attribute_ranges; 
   typedef Attribute_iterators       Attribute_handles;
@@ -1527,11 +393,12 @@ struct Combinatorial_map_helper
   { typedef Void type; };
 
   // Helper class allowing to retreive the d-cell-handle attribute
-  template<int d, class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
+  template<int d, class Type=typename
+	   CGAL::cpp0x::tuple_element<d,Attributes>::type>
   struct Attribute_handle
   {
-    typedef typename CGAL::cpp0x::tuple_element<Dimension_index<d>::value,Attribute_handles>::type 
-      type;
+    typedef typename CGAL::cpp0x::tuple_element
+    <Dimension_index<d>::value,Attribute_handles>::type type;
   };
   
   template<int d>
@@ -1539,7 +406,8 @@ struct Combinatorial_map_helper
   { typedef Void type; };
 
   // Helper class allowing to retreive the d-cell-const handle attribute
-  template<int d, class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type  >
+  template<int d,
+	   class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
   struct Attribute_const_handle
   {
     typedef typename CGAL::cpp0x::tuple_element<Dimension_index<d>::value,
@@ -1552,7 +420,8 @@ struct Combinatorial_map_helper
   { typedef Void type; };
 
   // Helper class allowing to retreive the d-cell-iterator attribute
-  template<int d, class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
+  template<int d,
+	   class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
   struct Attribute_iterator
   {
     typedef typename CGAL::cpp0x::tuple_element<Dimension_index<d>::value,
@@ -1565,12 +434,12 @@ struct Combinatorial_map_helper
   { typedef Void type; };
 
   // Helper class allowing to retreive the d-cell-const handle attribute
-  template<int d, class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type  >
+  template<int d,
+	   class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
   struct Attribute_const_iterator
   {
-    typedef typename CGAL::cpp0x::tuple_element<Dimension_index<d>::value,
-						Attribute_const_iterators>::type 
-      type;
+    typedef typename CGAL::cpp0x::tuple_element
+    <Dimension_index<d>::value, Attribute_const_iterators>::type type;
   };
   
   template<int d>
@@ -1591,29 +460,18 @@ struct Combinatorial_map_helper
   { typedef Void type; };
 
   // Helper class allowing to retreive the d-cell-attribute range
-  template<int d, class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type  >
+  template<int d,
+	   class Type=typename CGAL::cpp0x::tuple_element<d,Attributes>::type>
   struct Attribute_const_range
   {
-    typedef const typename CGAL::cpp0x::tuple_element<Dimension_index<d>::value,
-						      Attribute_ranges >::type 
-    type;
+    typedef const typename CGAL::cpp0x::tuple_element
+    <Dimension_index<d>::value, Attribute_ranges >::type type;
   };
   
   template<int d>
   struct Attribute_const_range<d,Void>
   { typedef Void type; };
 
-  #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-  // To iterate onto each dimension of the map
-  template <class Functor>
-  struct Foreach_dimension
-  {
-    template <class ...Ts>
-    static void run(const Ts& ... t)
-    { Foreach_static<Functor,CMap::dimension >::run(t...); }
-  };
-  #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
-
   // To iterate onto each enabled attributes
   #ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
   template <class Functor>
@@ -1624,44 +482,64 @@ struct Combinatorial_map_helper
     { Foreach_static_restricted<Functor,Attributes >::run(t...); }
   };
   #else
+  // This one cannot be moved in Combinatorial_map_utility_novariadic.h because
+  // this is an inner struct which uses inner type Attributes.
   template <class Functor>
   struct Foreach_enabled_attributes
   {
     static void run() {Foreach_static_restricted<Functor,Attributes >::run();}
     
     template <class T1>
-    static void run(const T1& t1) {Foreach_static_restricted<Functor,Attributes >::run(t1);}
+    static void run(const T1& t1)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1);}
 
     template <class T1,class T2>
-    static void run(const T1& t1,const T2& t2) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2);}
+    static void run(const T1& t1,const T2& t2)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2);}
 
     template <class T1,class T2,class T3>
-    static void run(const T1& t1,const T2& t2,const T3& t3) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3);}
+    static void run(const T1& t1,const T2& t2,const T3& t3)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3);}
 
     template <class T1,class T2,class T3,class T4>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4);}
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4);}
 
     template <class T1,class T2,class T3,class T4,class T5>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5);}            
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+		    const T5& t5)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5);}
 
     template <class T1,class T2,class T3,class T4,class T5,class T6>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6);}
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+		    const T5& t5,const T6& t6)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6);}
 
     template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,t7);}
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+		    const T5& t5,const T6& t6,const T7& t7)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,t7);}
 
-    template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,t7,t8);}
+    template <class T1,class T2,class T3,class T4,class T5,class T6,
+	      class T7,class T8>
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+		    const T5& t5,const T6& t6,const T7& t7,const T8& t8)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,
+							 t7,t8);}
 
-    template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7,const T8& t8,const T9& t9) {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);}
+    template <class T1,class T2,class T3,class T4,class T5,class T6,
+	      class T7,class T8,class T9>
+    static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+		    const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+		    const T9& t9)
+    {Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,
+							 t5,t6,t7,t8,t9);}
   };
   #endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
 };
 
+} //namespace internal
 
 } //namespace CGAL
 
-} //namespace internal
-
 #endif //CGAL_INTERNAL_COMBINATORIAL_MAP_UTILITY_H
diff --git a/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility_novariadic.h b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility_novariadic.h
new file mode 100644
index 00000000000..133d453dfab
--- /dev/null
+++ b/Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility_novariadic.h
@@ -0,0 +1,1641 @@
+// Copyright (c) 2010-2011 CNRS and LIRIS' Establishments (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation; either version 3 of the License,
+// or (at your option) any later version.
+//
+// Licensees holding a valid commercial license may use this file in
+// accordance with the commercial license agreement provided with the software.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// $URL$
+// $Id$
+//
+// Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
+//
+#ifndef CGAL_INTERNAL_COMBINATORIAL_MAP_UTILITY_NOVARIADIC_H
+#define CGAL_INTERNAL_COMBINATORIAL_MAP_UTILITY_NOVARIADIC_H 1
+
+#ifdef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits.hpp>
+
+// This file is included in Combinatorial_map_utility.h, in the namespace
+// CGAL::internal
+//------------------------------------------------------------------------------
+template <class T1>
+struct Convert_tuple_with_void;
+    
+template <>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<> >
+{
+  typedef CGAL::cpp0x::tuple<> type;
+};
+template <class T1>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type > type;
+};
+template <class T1, class T2>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type > type;
+};
+template <class T1, class T2, class T3>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type > type;
+};
+template <class T1, class T2, class T3, class T4>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type > type;
+};
+template <class T1, class T2, class T3, class T4, class T5>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4, T5> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type,
+                             typename Convert_void<T5>::type > type;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type,
+                             typename Convert_void<T5>::type,
+                             typename Convert_void<T6>::type > type;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type,
+                             typename Convert_void<T5>::type,
+                             typename Convert_void<T6>::type,
+                             typename Convert_void<T7>::type > type;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7, class T8>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type,
+                             typename Convert_void<T5>::type,
+                             typename Convert_void<T6>::type,
+                             typename Convert_void<T7>::type,
+                             typename Convert_void<T8>::type > type;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7, class T8, class T9>
+struct Convert_tuple_with_void<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,
+                                                  T7,T8,T9> >
+{
+  typedef CGAL::cpp0x::tuple<typename Convert_void<T1>::type,
+                             typename Convert_void<T2>::type,
+                             typename Convert_void<T3>::type,
+                             typename Convert_void<T4>::type,
+                             typename Convert_void<T5>::type,
+                             typename Convert_void<T6>::type,
+                             typename Convert_void<T7>::type,
+                             typename Convert_void<T8>::type,
+                             typename Convert_void<T9>::type > type;
+};
+//------------------------------------------------------------------------------
+template <class T>
+struct My_length;
+    
+template <>
+struct My_length<CGAL::cpp0x::tuple<> >
+{
+  static const int value = 0;
+};
+template <class T1>
+struct My_length<CGAL::cpp0x::tuple<T1> >
+{
+  static const int value = 1;
+};
+template <class T1, class T2>
+struct My_length<CGAL::cpp0x::tuple<T1,T2> >
+{
+  static const int value = 2;
+};
+template <class T1, class T2, class T3>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3> >
+{
+  static const int value = 3;
+};
+template <class T1, class T2, class T3, class T4>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4> >
+{
+  static const int value = 4;
+};
+template <class T1, class T2, class T3, class T4, class T5>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4, T5> >
+{
+  static const int value = 5;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
+{
+  static const int value = 6;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
+{
+  static const int value = 7;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7, class T8>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
+{
+  static const int value = 8;
+};
+template <class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7, class T8, class T9>
+struct My_length<CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >
+{
+  static const int value = 9;
+};
+//------------------------------------------------------------------------------
+template<class Type, class Tuple>
+struct Number_of_different_type_in_tuple;
+    
+template <class Type>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<> >
+{
+  static const int value=0;
+};
+    
+template <class Type, class T1>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1> >
+{
+  static const int value=boost::is_same<Type,T1>::value?0:1;
+};
+    
+template <class Type, class T1,class T2>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T2> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                      <T2,T3> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3,class T4>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                         <T1,T2,T3,T4> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple
+    <Type,CGAL::cpp0x::tuple<T2,T3,T4> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3,class T4,class T5>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,
+                                                                 T4,T5> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple
+    <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5> >::value;
+};
+
+template <class Type, class T1,class T2,class T3,class T4,class T5,class T6>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                         <T1,T2,T3,T4,T5,T6> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple
+    <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                         <T1,T2,T3,T4,T5,T6,T7> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                      <T2,T3,T4,T5,T6,T7> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7,class T8>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                         <T1,T2,T3,T4,T5,T6,T7,T8> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple
+    <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8> >::value;
+};
+    
+template <class Type, class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7,class T8,class T9>
+struct Number_of_different_type_in_tuple<Type,CGAL::cpp0x::tuple
+                                         <T1,T2,T3,T4,T5,T6,T7,T8,T9> >
+{
+  static const int value= (boost::is_same<Type,T1>::value?0:1) +
+    Number_of_different_type_in_tuple
+    <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9> >::value;
+};
+//------------------------------------------------------------------------------
+template <class Type, int k,class T,
+          int dim=CGAL::internal::My_length<T>::value-1>
+struct Nb_type_different_in_tuple_up_to_k;
+    
+template <class Type,int dim,int k,class T1>
+struct Nb_type_different_in_tuple_up_to_k<Type,k,
+                                          CGAL::cpp0x::tuple<T1>,dim >
+{
+  static const int pos=dim;
+  static const int value= pos==k?
+    boost::is_same<T1,Type>::value?-dim-1:0 : 0;
+};
+    
+template <class Type,int dim,int k,class T1,class T2>
+struct Nb_type_different_in_tuple_up_to_k<Type,k,
+                                          CGAL::cpp0x::tuple<T1,T2>,dim >
+{
+  static const int pos= Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2>,dim >::pos - 1;
+      
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2>,dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3>
+struct Nb_type_different_in_tuple_up_to_k<Type,k,
+                                          CGAL::cpp0x::tuple<T1,T2,T3>,dim >
+{
+  static const int pos = Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k<Type,k,
+                                                            CGAL::cpp0x::tuple<T2,T3>,dim >::value)
+         :0
+         );
+};
+
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4>
+struct Nb_type_different_in_tuple_up_to_k<Type,k,
+                                          CGAL::cpp0x::tuple<T1,T2,T3,T4>,dim >
+{
+  static const int pos= Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2,T3,T4>,dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4,
+          class T5>
+struct Nb_type_different_in_tuple_up_to_k
+<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5>,dim >
+{
+  static const int pos=Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5>,dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4,
+          class T5,class T6>
+struct Nb_type_different_in_tuple_up_to_k
+<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6>,dim >
+{
+  static const int pos=Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple
+                       <T2,T3,T4,T5,T6>,dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7>
+struct Nb_type_different_in_tuple_up_to_k
+<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7>,dim >{
+  static const int pos=Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,
+                        dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7,class T8>
+struct Nb_type_different_in_tuple_up_to_k
+<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8>,dim >
+{
+  static const int pos=Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,
+                        dim >::value)
+         :0
+         );
+};
+
+template <class Type,int dim,int k,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7,class T8,class T9>
+struct Nb_type_different_in_tuple_up_to_k
+<Type,k,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>,dim >
+{
+  static const int pos=Nb_type_different_in_tuple_up_to_k
+    <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,dim >::pos - 1;
+
+  static const int value =
+    ( pos==k  ) ?  ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
+    :  ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+                       + Nb_type_different_in_tuple_up_to_k
+                       <Type,k,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,
+                        dim >::value)
+         :0
+         );
+};
+//------------------------------------------------------------------------------
+//Convert a tuple of T... to a tuple of Functor<T>::type...
+template <template <class D> class Functor,class T>
+struct Tuple_converter;
+    
+template <template <class D> class Functor>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<> >{
+  typedef CGAL::cpp0x::tuple<> type;
+};
+
+template <template <class D> class Functor,class T1>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type > type;
+};
+
+template <template <class D> class Functor,class T1,class T2>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type > type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type ,
+                             typename Functor<T3>::type > type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4> >
+{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type> type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4,class T5>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type,
+                             typename Functor<T5>::type> type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4,class T5,class T6>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type,
+                             typename Functor<T5>::type,
+                             typename Functor<T6>::type> type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4,class T5,class T6,class T7>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type,
+                             typename Functor<T5>::type,
+                             typename Functor<T6>::type,
+                             typename Functor<T7>::type> type;
+};
+    
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4,class T5,class T6,class T7,class T8>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
+{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type,
+                             typename Functor<T5>::type,
+                             typename Functor<T6>::type,
+                             typename Functor<T7>::type,
+                             typename Functor<T8>::type> type;
+};
+
+template <template <class D> class Functor,class T1,class T2,class T3,
+          class T4,class T5,class T6,class T7,class T8,class T9>
+struct Tuple_converter<Functor,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,
+                                                  T8,T9> >
+{
+  typedef CGAL::cpp0x::tuple<typename Functor<T1>::type,
+                             typename Functor<T2>::type,
+                             typename Functor<T3>::type,
+                             typename Functor<T4>::type,
+                             typename Functor<T5>::type,
+                             typename Functor<T6>::type,
+                             typename Functor<T7>::type,
+                             typename Functor<T8>::type,
+                             typename Functor<T9>::type> type;
+};
+//------------------------------------------------------------------------------
+template <class Type,class Tuple>
+struct Append_to_tuple;
+  
+template <class Type>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<> >
+{ typedef CGAL::cpp0x::tuple<Type> type; };
+
+template <class Type,class T1>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1> >
+{ typedef CGAL::cpp0x::tuple<T1,Type> type; };
+
+template <class Type,class T1,class T2>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,Type> type; };
+
+template <class Type,class T1,class T2,class T3>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4,class T5>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4,class T5,class T6>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7,class T8>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,Type> type; };
+
+template <class Type,class T1,class T2,class T3,class T4,class T5,class T6,
+          class T7,class T8,class T9>
+struct Append_to_tuple<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >
+{ typedef CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,Type> type; };
+//------------------------------------------------------------------------------
+template <class Type,class Tuple,class Result=CGAL::cpp0x::tuple<> >
+struct Keep_type_different_of;
+
+template <class Type,class Result>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<>,Result> {
+  typedef Result type;
+};  
+  
+template <class Type,class T1,class Result>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1>,Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type type;
+};
+
+template <class Type,class Result,class T1,class T2>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2>,Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2>,New_result>::type type;
+};
+    
+template <class Type,class Result,class T1,class T2,class T3>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3>,Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3>,New_result>::type type;
+};
+
+template <class Type,class Result,class T1,class T2,class T3,class T4>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4>,Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4>,New_result>::type type;
+};
+
+template <class Type,class Result,class T1,class T2,class T3,class T4,
+          class T5>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5>,
+                              Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5>,New_result>::type type;
+};
+
+template <class Type,class Result,class T1,class T2,class T3,class T4,
+          class T5,class T6>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6>,
+                              Result>
+{
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6>,New_result>::type type;
+};
+    
+template <class Type,class Result,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7>,
+                              Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7>,New_result>::type type;
+};
+
+template <class Type,class Result,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7,class T8>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,
+                                                      T7,T8>,Result> {
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8>,New_result>::type type;
+};
+
+template <class Type,class Result,class T1,class T2,class T3,class T4,
+          class T5,class T6,class T7,class T8,class T9>
+struct Keep_type_different_of<Type,CGAL::cpp0x::tuple<T1,T2,T3,T4,T5,T6,T7,
+                                                      T8,T9>,Result>{
+  typedef typename boost::mpl::if_
+  < typename boost::is_same<T1,Type>::type,Result,typename Append_to_tuple
+    <T1,Result>::type  >::type New_result;
+  typedef typename Keep_type_different_of
+  <Type,CGAL::cpp0x::tuple<T2,T3,T4,T5,T6,T7,T8,T9>,New_result>::type type;
+};
+//------------------------------------------------------------------------------
+template <class Functor,int n>
+struct Foreach_static
+{
+  static void run() 
+  {
+    Functor:: template run<n>();
+    Foreach_static<Functor,n-1>::run();
+  }
+
+  template<class T1>
+  static void run(const T1& t1) 
+  {
+    Functor:: template run<n>(t1);
+    Foreach_static<Functor,n-1>::run(t1);
+  }
+
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2) 
+  {
+    Functor:: template run<n>(t1,t2);
+    Foreach_static<Functor,n-1>::run(t1,t2);
+  }
+  
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3)
+  {
+    Functor:: template run<n>(t1,t2,t3);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3);
+  }
+  
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static<Functor,n-1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor>
+struct Foreach_static<Functor,0>
+{
+  static void run() 
+  {
+    Functor:: template run<0>();
+  }
+
+  template<class T1>
+  static void run(const T1& t1) 
+  {
+    Functor:: template run<0>(t1);
+  }
+
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2) 
+  {
+    Functor:: template run<0>(t1,t2);
+  }
+  
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3)
+  {
+    Functor:: template run<0>(t1,t2,t3);
+  }
+  
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4,t5);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4,t5,t6);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,
+           class T7,class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9)
+  {
+    Functor:: template run<0>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }  
+};
+//------------------------------------------------------------------------------
+template <class Functor,int n,class Type>
+struct Conditionnal_run{
+  static void run() 
+  {
+    Functor:: template run<n>();
+  }
+
+  template<class T1>
+  static void run(const T1& t1) 
+  {
+    Functor:: template run<n>(t1);
+  }
+
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2) 
+  {
+    Functor:: template run<n>(t1,t2);
+  }
+  
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3)
+  {
+    Functor:: template run<n>(t1,t2,t3);
+  }
+  
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5);
+  }
+  
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9)
+  {
+    Functor:: template run<n>(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }  
+};
+//------------------------------------------------------------------------------
+template <class Functor,int n>
+struct Conditionnal_run<Functor,n,Void>
+{
+  static void run(){}
+
+  template<class T1>
+  static void run(const T1&){}
+
+  template<class T1,class T2>
+  static void run(const T1&,const T2&){}
+  
+  template<class T1,class T2,class T3>
+  static void run(const T1&,const T2&,const T3&){}
+  
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1&,const T2&,const T3&,const T4&){}
+  
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&){}
+  
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,
+                  const T6&){}
+      
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,
+                  const T6&,const T7&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,
+                  const T6&,const T7&,const T8&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,
+                  const T6&,const T7&,const T8&,const T9&){}
+};
+//------------------------------------------------------------------------------
+template <class Functor,class T,int n=0>
+struct Foreach_static_restricted;
+
+template <class Functor,class TT1,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                                 <TT1,TT2,TT3,TT4>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }  
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,
+          class TT5,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                                 <TT1,TT2,TT3,TT4,TT5>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,
+          class TT6,int n>
+struct Foreach_static_restricted
+<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,
+          class TT6,class TT7,int n>
+struct Foreach_static_restricted
+<Functor,CGAL::cpp0x::tuple<TT1,TT2,TT3,TT4,TT5,TT6,TT7>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,n+1>::run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,
+                              n+1>::run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,
+                              CGAL::cpp0x::tuple<TT2,TT3,TT4,TT5,TT6,TT7>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7>,
+                              n+1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,
+          class TT6,class TT7,class TT8,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                                 <TT1,TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run();
+  }
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1);
+  }
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1,t2);
+  }
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::run(t1,t2,t3);
+  }
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,class TT1,class TT2,class TT3,class TT4,class TT5,
+          class TT6,class TT7,class TT8,class TT9,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                                 <TT1,TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n>
+{
+  static void run(){
+    Conditionnal_run<Functor,n,TT1>::run();
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run();
+  }
+
+  template<class T1>
+  static void run(const T1& t1){
+    Conditionnal_run<Functor,n,TT1>::run(t1);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::run(t1);
+  }
+
+  template<class T1,class T2>
+  static void run(const T1& t1,const T2& t2){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2);
+  }
+
+  template<class T1,class T2,class T3>
+  static void run(const T1& t1,const T2& t2,const T3& t3){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3);
+  }
+
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4);
+  }
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4,t5);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4,t5,t6);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8);
+  }
+  template<class T1,class T2,class T3,class T4,class T5,class T6,class T7,
+           class T8,class T9>
+  static void run(const T1& t1,const T2& t2,const T3& t3,const T4& t4,
+                  const T5& t5,const T6& t6,const T7& t7,const T8& t8,
+                  const T9& t9){
+    Conditionnal_run<Functor,n,TT1>::run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+    Foreach_static_restricted<Functor,CGAL::cpp0x::tuple
+                              <TT2,TT3,TT4,TT5,TT6,TT7,TT8,TT9>,n+1>::
+      run(t1,t2,t3,t4,t5,t6,t7,t8,t9);
+  }
+};
+//------------------------------------------------------------------------------
+template <class Functor,int n>
+struct Foreach_static_restricted<Functor,CGAL::cpp0x::tuple<>,n>{
+  static void run(){}
+
+  template<class T1>
+  static void run(const T1&){}
+
+  template<class T1,class T2>
+  static void run(const T1&,const T2&){}
+  
+  template<class T1,class T2,class T3>
+  static void run(const T1&,const T2&,const T3&){}
+  
+  template<class T1,class T2,class T3,class T4>
+  static void run(const T1&,const T2&,const T3&,const T4&){}
+
+  template<class T1,class T2,class T3,class T4,class T5>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6, class T7>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,
+                  const T7&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6, class T7,
+           class T8>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,
+                  const T7&,const T8&){}
+
+  template<class T1,class T2,class T3,class T4,class T5,class T6, class T7,
+           class T8, class T9>
+  static void run(const T1&,const T2&,const T3&,const T4&,const T5&,const T6&,
+                  const T7&,const T8&,const T9&){}
+};
+    
+#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+
+#endif //CGAL_INTERNAL_COMBINATORIAL_MAP_UTILITY_NOVARIADIC_H
+