Index: lemon/elevator.h
===================================================================
--- lemon/elevator.h	(revision 559)
+++ lemon/elevator.h	(revision 581)
@@ -77,5 +77,5 @@
     void copy(Item i, Vit p)
     {
-      _where.set(*p=i,p);
+      _where[*p=i] = p;
     }
     void copy(Vit s, Vit p)
@@ -85,5 +85,5 @@
           Item i=*s;
           *p=i;
-          _where.set(i,p);
+          _where[i] = p;
         }
     }
@@ -92,6 +92,6 @@
       Item ti=*i;
       Vit ct = _where[ti];
-      _where.set(ti,_where[*i=*j]);
-      _where.set(*j,ct);
+      _where[ti] = _where[*i=*j];
+      _where[*j] = ct;
       *j=ti;
     }
@@ -227,5 +227,5 @@
     {
       Item it = *_last_active[_highest_active];
-      _level.set(it,_level[it]+1);
+      ++_level[it];
       swap(_last_active[_highest_active]--,_last_active[_highest_active+1]);
       --_first[++_highest_active];
@@ -250,5 +250,5 @@
         }
       copy(li,_first[new_level]);
-      _level.set(li,new_level);
+      _level[li] = new_level;
       _highest_active=new_level;
     }
@@ -270,5 +270,5 @@
       copy(li,_first[_max_level]);
       --_last_active[_max_level];
-      _level.set(li,_max_level);
+      _level[li] = _max_level;
 
       while(_highest_active>=0 &&
@@ -300,5 +300,5 @@
     {
       Item it =*_last_active[level];
-      _level.set(it,_level[it]+1);
+      ++_level[it];
       swap(_last_active[level]--, --_first[level+1]);
       if (level+1>_highest_active) ++_highest_active;
@@ -320,5 +320,5 @@
         }
       copy(ai,_first[new_level]);
-      _level.set(ai,new_level);
+      _level[ai] = new_level;
       if (new_level>_highest_active) _highest_active=new_level;
     }
@@ -340,5 +340,5 @@
       copy(ai,_first[_max_level]);
       --_last_active[_max_level];
-      _level.set(ai,_max_level);
+      _level[ai] = _max_level;
 
       if (_highest_active==level) {
@@ -371,5 +371,5 @@
         }
       copy(i,_first[new_level]);
-      _level.set(i,new_level);
+      _level[i] = new_level;
       if(new_level>_highest_active) _highest_active=new_level;
     }
@@ -383,5 +383,5 @@
     ///\pre The item is on the top level.
     void dirtyTopButOne(Item i) {
-      _level.set(i,_max_level - 1);
+      _level[i] = _max_level - 1;
     }
 
@@ -395,5 +395,5 @@
       const Vit tl=_first[_max_level];
       for(Vit i=f;i!=tl;++i)
-        _level.set(*i,_max_level);
+        _level[*i] = _max_level;
       for(int i=l;i<=_max_level;i++)
         {
@@ -434,6 +434,6 @@
         {
           *n=i;
-          _where.set(i,n);
-          _level.set(i,_max_level);
+          _where[i] = n;
+          _level[i] = _max_level;
           ++n;
         }
@@ -444,5 +444,5 @@
     {
       swap(_where[i],_init_num);
-      _level.set(i,_init_lev);
+      _level[i] = _init_lev;
       ++_init_num;
     }
@@ -552,5 +552,5 @@
     ///\pre Item \c i shouldn't be active before.
     void activate(Item i) {
-      _active.set(i, true);
+      _active[i] = true;
 
       int level = _level[i];
@@ -561,14 +561,14 @@
       if (_prev[i] == INVALID || _active[_prev[i]]) return;
       //unlace
-      _next.set(_prev[i], _next[i]);
+      _next[_prev[i]] = _next[i];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], _prev[i]);
+        _prev[_next[i]] = _prev[i];
       } else {
         _last[level] = _prev[i];
       }
       //lace
-      _next.set(i, _first[level]);
-      _prev.set(_first[level], i);
-      _prev.set(i, INVALID);
+      _next[i] = _first[level];
+      _prev[_first[level]] = i;
+      _prev[i] = INVALID;
       _first[level] = i;
 
@@ -580,5 +580,5 @@
     ///\pre Item \c i must be active before.
     void deactivate(Item i) {
-      _active.set(i, false);
+      _active[i] = false;
       int level = _level[i];
 
@@ -587,14 +587,14 @@
 
       //unlace
-      _prev.set(_next[i], _prev[i]);
+      _prev[_next[i]] = _prev[i];
       if (_prev[i] != INVALID) {
-        _next.set(_prev[i], _next[i]);
+        _next[_prev[i]] = _next[i];
       } else {
         _first[_level[i]] = _next[i];
       }
       //lace
-      _prev.set(i, _last[level]);
-      _next.set(_last[level], i);
-      _next.set(i, INVALID);
+      _prev[i] = _last[level];
+      _next[_last[level]] = i;
+      _next[i] = INVALID;
       _last[level] = i;
 
@@ -686,5 +686,5 @@
       Item i = _first[_highest_active];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[_highest_active] = _next[i];
       } else {
@@ -692,13 +692,13 @@
         _last[_highest_active] = INVALID;
       }
-      _level.set(i, ++_highest_active);
+      _level[i] = ++_highest_active;
       if (_first[_highest_active] == INVALID) {
         _first[_highest_active] = i;
         _last[_highest_active] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(_first[_highest_active], i);
-        _next.set(i, _first[_highest_active]);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[_first[_highest_active]] = i;
+        _next[i] = _first[_highest_active];
         _first[_highest_active] = i;
       }
@@ -715,5 +715,5 @@
       Item i = _first[_highest_active];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[_highest_active] = _next[i];
       } else {
@@ -721,12 +721,12 @@
         _last[_highest_active] = INVALID;
       }
-      _level.set(i, _highest_active = new_level);
+      _level[i] = _highest_active = new_level;
       if (_first[_highest_active] == INVALID) {
         _first[_highest_active] = _last[_highest_active] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(_first[_highest_active], i);
-        _next.set(i, _first[_highest_active]);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[_first[_highest_active]] = i;
+        _next[i] = _first[_highest_active];
         _first[_highest_active] = i;
       }
@@ -739,7 +739,7 @@
     void liftHighestActiveToTop() {
       Item i = _first[_highest_active];
-      _level.set(i, _max_level);
+      _level[i] = _max_level;
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[_highest_active] = _next[i];
       } else {
@@ -775,5 +775,5 @@
       Item i = _first[l];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[l] = _next[i];
       } else {
@@ -781,12 +781,12 @@
         _last[l] = INVALID;
       }
-      _level.set(i, ++l);
+      _level[i] = ++l;
       if (_first[l] == INVALID) {
         _first[l] = _last[l] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(_first[l], i);
-        _next.set(i, _first[l]);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[_first[l]] = i;
+        _next[i] = _first[l];
         _first[l] = i;
       }
@@ -804,5 +804,5 @@
       Item i = _first[l];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[l] = _next[i];
       } else {
@@ -810,12 +810,12 @@
         _last[l] = INVALID;
       }
-      _level.set(i, l = new_level);
+      _level[i] = l = new_level;
       if (_first[l] == INVALID) {
         _first[l] = _last[l] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(_first[l], i);
-        _next.set(i, _first[l]);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[_first[l]] = i;
+        _next[i] = _first[l];
         _first[l] = i;
       }
@@ -833,5 +833,5 @@
       Item i = _first[l];
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], INVALID);
+        _prev[_next[i]] = INVALID;
         _first[l] = _next[i];
       } else {
@@ -839,5 +839,5 @@
         _last[l] = INVALID;
       }
-      _level.set(i, _max_level);
+      _level[i] = _max_level;
       if (l == _highest_active) {
         while (_highest_active >= 0 && activeFree(_highest_active))
@@ -857,21 +857,21 @@
     void lift(Item i, int new_level) {
       if (_next[i] != INVALID) {
-        _prev.set(_next[i], _prev[i]);
+        _prev[_next[i]] = _prev[i];
       } else {
         _last[new_level] = _prev[i];
       }
       if (_prev[i] != INVALID) {
-        _next.set(_prev[i], _next[i]);
+        _next[_prev[i]] = _next[i];
       } else {
         _first[new_level] = _next[i];
       }
-      _level.set(i, new_level);
+      _level[i] = new_level;
       if (_first[new_level] == INVALID) {
         _first[new_level] = _last[new_level] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(_first[new_level], i);
-        _next.set(i, _first[new_level]);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[_first[new_level]] = i;
+        _next[i] = _first[new_level];
         _first[new_level] = i;
       }
@@ -889,5 +889,5 @@
     ///\pre The item is on the top level.
     void dirtyTopButOne(Item i) {
-      _level.set(i, _max_level - 1);
+      _level[i] = _max_level - 1;
     }
 
@@ -900,5 +900,5 @@
         Item n = _first[i];
         while (n != INVALID) {
-          _level.set(n, _max_level);
+          _level[n] = _max_level;
           n = _next[n];
         }
@@ -938,6 +938,6 @@
       for(typename ItemSetTraits<GR,Item>::ItemIt i(_graph);
           i != INVALID; ++i) {
-        _level.set(i, _max_level);
-        _active.set(i, false);
+        _level[i] = _max_level;
+        _active[i] = false;
       }
     }
@@ -945,14 +945,14 @@
     ///Add an item to the current level.
     void initAddItem(Item i) {
-      _level.set(i, _init_level);
+      _level[i] = _init_level;
       if (_last[_init_level] == INVALID) {
         _first[_init_level] = i;
         _last[_init_level] = i;
-        _prev.set(i, INVALID);
-        _next.set(i, INVALID);
-      } else {
-        _prev.set(i, _last[_init_level]);
-        _next.set(i, INVALID);
-        _next.set(_last[_init_level], i);
+        _prev[i] = INVALID;
+        _next[i] = INVALID;
+      } else {
+        _prev[i] = _last[_init_level];
+        _next[i] = INVALID;
+        _next[_last[_init_level]] = i;
         _last[_init_level] = i;
       }
