Index: kernel/f5lists.cc
===================================================================
--- kernel/f5lists.cc	(revision 0179d569cebe4081f964479a71818cd5d80626ee)
+++ kernel/f5lists.cc	(revision a05c71fc3b41d3b12e7444da8ad632c0cdb6b3b2)
@@ -30,10 +30,10 @@
     next                =   NULL;
 }
-LNode::LNode(LPoly* lp) {
+LNode::LNode(LPolyOld* lp) {
     data                =   lp;
     next                =   NULL;
 }
        
-LNode::LNode(LPoly* lp, LNode* l) {
+LNode::LNode(LPolyOld* lp, LNode* l) {
 //Print("HIER LNODE\n");
     data                =   lp;
@@ -41,12 +41,12 @@
 }
 
-LNode::LNode(poly t, int i, poly p, Rule* r) {
-LPoly* lp           =   new LPoly(t,i,p,r);
+LNode::LNode(poly t, int i, poly p, RuleOld* r) {
+LPolyOld* lp           =   new LPolyOld(t,i,p,r);
 data                =   lp;
 next                =   NULL;
 }
        
-LNode::LNode(poly t, int i, poly p, Rule* r, LNode* l) {
-    LPoly* lp           =   new LPoly(t,i,p,r);
+LNode::LNode(poly t, int i, poly p, RuleOld* r, LNode* l) {
+    LPolyOld* lp           =   new LPolyOld(t,i,p,r);
     data                =   lp;
     next                =   l;
@@ -54,5 +54,5 @@
 
 LNode::LNode(LNode* ln) {
-    data                =   ln->getLPoly();
+    data                =   ln->getLPolyOld();
     next                =   ln->getNext();
 }
@@ -75,5 +75,5 @@
 // insert new elements to the list always at the end (labeled / classical polynomial view)
 // needed for list gPrev
-inline LNode* LNode::insert(LPoly* lp) {
+inline LNode* LNode::insert(LPolyOld* lp) {
     //Print("LAST GPREV: ");
     //pWrite(this->getPoly());
@@ -89,5 +89,5 @@
 }
         
-inline LNode* LNode::insert(poly t, int i, poly p, Rule* r) {
+inline LNode* LNode::insert(poly t, int i, poly p, RuleOld* r) {
     if(NULL == this) {
         LNode* newElement   =   new LNode(t,i,p,r,this);
@@ -103,5 +103,5 @@
 // insert new elements to the list always in front (labeled / classical polynomial view)
 // needed for sPolyList
-inline LNode* LNode::insertSP(LPoly* lp) {
+inline LNode* LNode::insertSP(LPolyOld* lp) {
     LNode* newElement   =   new LNode(lp, this);
     //Print("INSERTED IN SPOLYLIST: ");
@@ -110,5 +110,5 @@
 }
         
-inline LNode* LNode::insertSP(poly t, int i, poly p, Rule* r) {
+inline LNode* LNode::insertSP(poly t, int i, poly p, RuleOld* r) {
     LNode* newElement   =   new LNode(t, i, p, r, this);
      //Print("INSERTED IN SPOLYLIST: ");
@@ -118,5 +118,5 @@
 // insert new elemets to the list w.r.t. increasing labels
 // only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
-inline LNode* LNode::insertByLabel(poly t, int i, poly p, Rule* r) {
+inline LNode* LNode::insertByLabel(poly t, int i, poly p, RuleOld* r) {
     //Print("ADDING SOLYS TO THE LIST\n");
     //Print("new element: ");
@@ -222,10 +222,10 @@
 }
 
-// get the LPoly* out of LNode*
-LPoly* LNode::getLPoly() {
+// get the LPolyOld* out of LNode*
+LPolyOld* LNode::getLPolyOld() {
     return data;
 }
 
-// get the data from the LPoly saved in LNode
+// get the data from the LPolyOld saved in LNode
 poly LNode::getPoly() {
     return data->getPoly();
@@ -240,10 +240,10 @@
 }
 
-Rule* LNode::getRule() {
-    return data->getRule();
-}
-
-void LNode::setRule(Rule* r) {
-    return data->setRule(r);
+RuleOld* LNode::getRuleOld() {
+    return data->getRuleOld();
+}
+
+void LNode::setRuleOld(RuleOld* r) {
+    return data->setRuleOld(r);
 }
 
@@ -252,5 +252,5 @@
 }
 
-// set the data from the LPoly saved in LNode
+// set the data from the LPolyOld saved in LNode
 void LNode::setPoly(poly p) {
     data->setPoly(p);
@@ -333,5 +333,5 @@
 }
 
-LList::LList(LPoly* lp) {
+LList::LList(LPolyOld* lp) {
     first   =   new LNode(lp);
     last    =   first;
@@ -339,5 +339,5 @@
 }
 
-LList::LList(poly t,int i,poly p,Rule* r) {
+LList::LList(poly t,int i,poly p,RuleOld* r) {
     first   =   new LNode(t,i,p,r);
     last    =   first;
@@ -356,5 +356,5 @@
 
 // insertion at the end of the list, needed for gPrev
-void LList::insert(LPoly* lp) {
+void LList::insert(LPolyOld* lp) {
     last = last->insert(lp);
     if(NULL == first) {
@@ -369,5 +369,5 @@
 }
 
-void LList::insert(poly t,int i, poly p, Rule* r) {
+void LList::insert(poly t,int i, poly p, RuleOld* r) {
     last = last->insert(t,i,p,r);
     if(NULL == first) {
@@ -379,5 +379,5 @@
 
 // insertion in front of the list, needed for sPolyList
-void LList::insertSP(LPoly* lp) {
+void LList::insertSP(LPolyOld* lp) {
     first = first->insertSP(lp);
     length++;
@@ -385,5 +385,5 @@
 }
 
-void LList::insertSP(poly t,int i, poly p, Rule* r) {
+void LList::insertSP(poly t,int i, poly p, RuleOld* r) {
     first = first->insertSP(t,i,p,r);
     length++;
@@ -392,5 +392,5 @@
 
 
-void LList::insertByLabel(poly t, int i, poly p, Rule* r) {
+void LList::insertByLabel(poly t, int i, poly p, RuleOld* r) {
     first = first->insertByLabel(t,i,p,r);
     length++;
@@ -483,5 +483,5 @@
 
 // NOTE: We insert at the beginning of the list and length = i-1, where i is the actual index.
-//       Thus given actual index i and idx being the index of the LPoly under investigation
+//       Thus given actual index i and idx being the index of the LPolyOld under investigation
 //       the element on position length-idx is the right one
 LNode* LTagNode::get(int idx, int length) {
@@ -719,9 +719,9 @@
 }
 
-LPoly* CNode::getAdLp1() {
+LPolyOld* CNode::getAdLp1() {
     return this->data->getAdLp1();
 }
 
-LPoly* CNode::getAdLp2() {
+LPolyOld* CNode::getAdLp2() {
     return this->data->getAdLp2();
 }
@@ -767,6 +767,6 @@
 }
 
-Rule* CNode::getTestedRule() {
-    return this->data->getTestedRule();
+RuleOld* CNode::getTestedRuleOld() {
+    return this->data->getTestedRuleOld();
 }
 
@@ -854,5 +854,5 @@
 }
 
-RNode::RNode(Rule* r) {
+RNode::RNode(RuleOld* r) {
     data    =   r;
     next    =   NULL;
@@ -860,9 +860,9 @@
 
 RNode::~RNode() {
-    //Print("DELETE RULE\n");
+    //Print("DELETE RuleOld\n");
     delete  data;
 }
 
-RNode* RNode::insert(Rule* r) {
+RNode* RNode::insert(RuleOld* r) {
     RNode* newElement   =   new RNode(r);
     newElement->next    =   this;
@@ -873,9 +873,9 @@
     //Print("IN INSERT: ");
     //pWrite(t);
-    Rule*   r           =   new Rule(i,t);
-    //Print("ADDRESS OF RULE: %p\n",r);
+    RuleOld*   r           =   new RuleOld(i,t);
+    //Print("ADDRESS OF RuleOld: %p\n",r);
     RNode* newElement   =   new RNode(r);
     //Print("ADDRESS OF RNODE: %p\n",newElement);
-    //Print("ADDRESS OF RNODE DATA: %p\n",newElement->getRule());
+    //Print("ADDRESS OF RNODE DATA: %p\n",newElement->getRuleOld());
     newElement->next    =   this;
     return newElement;
@@ -883,5 +883,5 @@
 
 
-RNode* RNode::insertOrdered(Rule* r) {
+RNode* RNode::insertOrdered(RuleOld* r) {
     RNode* newElement   =   new RNode(r); 
     RNode* temp         =   this;
@@ -890,10 +890,10 @@
         return newElement;
     }
-    if(1 == pLmCmp(newElement->getRuleTerm(),temp->getRuleTerm())) {
+    if(1 == pLmCmp(newElement->getRuleOldTerm(),temp->getRuleOldTerm())) {
         newElement->next =   temp;
         return newElement;
     }
     else {
-        while(NULL != temp && 1 ==  pLmCmp(temp->getRuleTerm(),newElement->getRuleTerm())) {
+        while(NULL != temp && 1 ==  pLmCmp(temp->getRuleOldTerm(),newElement->getRuleOldTerm())) {
             temp    =   temp->getNext();
         }
@@ -908,13 +908,13 @@
 }    
 
-Rule* RNode::getRule() {
+RuleOld* RNode::getRuleOld() {
     return data;
 }
 
-int RNode::getRuleIndex() {
+int RNode::getRuleOldIndex() {
     return data->getIndex();
 }
 
-poly RNode::getRuleTerm() {
+poly RNode::getRuleOldTerm() {
     return data->getTerm();
 }
@@ -923,6 +923,6 @@
     RNode* temp  =   this;
     while(NULL != temp) {
-        pWrite(temp->getRuleTerm());
-        Print("%d\n\n",temp->getRuleIndex());
+        pWrite(temp->getRuleOldTerm());
+        Print("%d\n\n",temp->getRuleOldIndex());
         temp    =   temp->getNext();
     }
@@ -938,5 +938,5 @@
 }
 
-RList::RList(Rule* r) {
+RList::RList(RuleOld* r) {
     first = new RNode(r);
 }
@@ -950,8 +950,8 @@
         //Print("1 %p\n",first);
         //if(first) {
-            //Print("1' %p\n",first->getRule());
+            //Print("1' %p\n",first->getRuleOld());
             //Print("2 %p\n",first->getNext());
-            //Print("3 %p\n",first->getNext()->getRule());
-            //Print("3 %p\n",first->getNext()->getRuleTerm());
+            //Print("3 %p\n",first->getNext()->getRuleOld());
+            //Print("3 %p\n",first->getNext()->getRuleOldTerm());
         //}
         delete  temp;
@@ -964,9 +964,9 @@
 }
 
-void RList::insert(Rule* r) {
+void RList::insert(RuleOld* r) {
     first = first->insert(r);
 }
 
-void RList::insertOrdered(Rule* r) {
+void RList::insertOrdered(RuleOld* r) {
     first   =   first->insertOrdered(r);
 }
@@ -976,6 +976,6 @@
 }
 
-Rule* RList::getRule() {
-    return this->getRule();
+RuleOld* RList::getRuleOld() {
+    return this->getRuleOld();
 }
 
@@ -1029,5 +1029,5 @@
 
 // NOTE: We insert at the beginning of the list and length = i-1, where i is the actual index.
-//       Thus given actual index i and idx being the index of the LPoly under investigation
+//       Thus given actual index i and idx being the index of the LPolyOld under investigation
 //       the element on position length-idx+1 is the right one
 RNode* RTagNode::get(int idx, int length) {
@@ -1058,11 +1058,11 @@
     RTagNode* temp  =   this;
     if(NULL != temp && NULL != temp->getRNode()) {
-        Print("1. element: %d,  ",getRNode()->getRule()->getIndex());
-        pWrite(getRNode()->getRule()->getTerm());
+        Print("1. element: %d,  ",getRNode()->getRuleOld()->getIndex());
+        pWrite(getRNode()->getRuleOld()->getTerm());
         temp    =   temp->next;
         int i   =   2;
         while(NULL != temp->getRNode() && NULL != temp) {
-            Print("%d. element: %d,  ",i,getRNode()->getRule()->getIndex());
-            pWrite(getRNode()->getRule()->getTerm());
+            Print("%d. element: %d,  ",i,getRNode()->getRuleOld()->getIndex());
+            pWrite(getRNode()->getRuleOld()->getTerm());
             temp    =   temp->next;
             i++;
