after merge (mostly tabbing issues)

diff --combined src/ASTTransform/elementopt.cc
index 25de874bf70a4f08e5c4034bd891e10cb63c2663,6fec15597d29f84d21b7cef38130ee7467eca364..44773795c965a180014fdcae8a0788974cecb7dc
mode 100755,100644..100644
--- 1/src/ASTTransform/elementopt.cc
--- 2/src/ASTTransform/elementopt.cc
+++ b/src/ASTTransform/elementopt.cc
@@@ -9,7 -9,7 +9,7 @@@
  
  ElementOpt::ElementOpt(CSolver *_solver)
        : Transform(_solver),
-               updateSets(solver->getTuner()->getTunable(ELEMENTOPTSETS, &onoff) == 1)
+       updateSets(solver->getTuner()->getTunable(ELEMENTOPTSETS, &onoff) == 1)
  {
  }
  
@@@ -19,7 -19,7 +19,7 @@@ ElementOpt::~ElementOpt() 
  void ElementOpt::doTransform() {
        if (solver->getTuner()->getTunable(ELEMENTOPT, &onoff) == 0)
                return;
-       
+ 
        SetIteratorBooleanEdge *iterator = solver->getConstraints();
        while (iterator->hasNext()) {
                BooleanEdge constraint = iterator->next();
@@@ -27,38 -27,38 +27,38 @@@
                        workList.push((BooleanPredicate *)constraint.getBoolean());
        }
        while (workList.getSize() != 0) {
-               BooleanPredicate * pred = workList.last(); workList.pop();
+               BooleanPredicate *pred = workList.last(); workList.pop();
                processPredicate(pred);
        }
        delete iterator;
  }
  
- void ElementOpt::processPredicate(BooleanPredicate * pred) {
+ void ElementOpt::processPredicate(BooleanPredicate *pred) {
        uint numInputs = pred->inputs.getSize();
        if (numInputs != 2)
                return;
  
-       Predicate * p = pred->getPredicate();
+       Predicate *p = pred->getPredicate();
        if (p->type == TABLEPRED)
-                       return;
+               return;
  
-       PredicateOperator * pop = (PredicateOperator *) p;
+       PredicateOperator *pop = (PredicateOperator *) p;
        CompOp op = pop->getOp();
  
-       Element * left = pred->inputs.get(0);
-       Element * right = pred->inputs.get(1);
+       Element *left = pred->inputs.get(0);
+       Element *right = pred->inputs.get(1);
  
        if (left->type == ELEMCONST) {
-               Element * tmp = left;
+               Element *tmp = left;
                left = right;
                right = tmp;
                op = flipOp(op);
        } else if (right->type != ELEMCONST)
                return;
  
-       if (left->type !=ELEMSET)
+       if (left->type != ELEMSET)
                return;
-       
+ 
        if (op == SATC_EQUALS) {
                handlePredicateEquals(pred, (ElementSet *) left, (ElementConst *) right);
        } else if (updateSets) {
@@@ -71,12 -71,12 +71,12 @@@ void ElementOpt::handlePredicateEquals(
                replaceVarWithConst(pred, left, right);
        } else if (pred->isFalse() && updateSets) {
                constrainVarWithConst(pred, left, right);
 -      } else ASSERT(0);
 +      }
  }
  
  void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
-       Predicate * p = pred->getPredicate();
-       PredicateOperator * pop = (PredicateOperator *) p;
+       Predicate *p = pred->getPredicate();
+       PredicateOperator *pop = (PredicateOperator *) p;
        CompOp op = pop->getOp();
  
        if (pred->isFalse()) {
@@@ -85,18 -85,18 +85,18 @@@
                ASSERT(0);
        }
  
-       Set * s = var->getRange();
+       Set *s = var->getRange();
        if (s->isRange)
                return;
-       
+ 
        uint size = s->getSize();
        uint64_t elemArray[size];
        uint count = 0;
        uint64_t cvalue = value->value;
  
-       switch(op) {
+       switch (op) {
        case SATC_LT: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val < cvalue)
                                elemArray[count++] = val;
@@@ -104,7 -104,7 +104,7 @@@
                break;
        }
        case SATC_GT: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val > cvalue)
                                elemArray[count++] = val;
@@@ -112,7 -112,7 +112,7 @@@
                break;
        }
        case SATC_LTE: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val <= cvalue)
                                elemArray[count++] = val;
@@@ -120,40 -120,40 +120,40 @@@
                break;
        }
        case SATC_GTE: {
-               for(uint i=0; i<size; i++) {
+               for (uint i = 0; i < size; i++) {
                        uint64_t val = s->getElement(i);
                        if (val >= cvalue)
                                elemArray[count++] = val;
                }
                break;
        }
-               
+ 
        default:
                ASSERT(0);
        }
        if (size == count)
                return;
-       
+ 
        Set *newset = solver->createSet(s->type, elemArray, count);
        solver->elemMap.remove(var);
        var->set = newset;
        solver->elemMap.put(var, var);
  
        if (count == 1) {
-               ElementConst * elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
+               ElementConst *elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
                replaceVarWithConst(pred, var, elemconst);
        }
  }
  
  void ElementOpt::constrainVarWithConst(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
-       Set * s = var->getRange();
+       Set *s = var->getRange();
        if (s->isRange)
                return;
        uint size = s->getSize();
        uint64_t elemArray[size];
        uint count = 0;
        uint64_t cvalue = value->value;
-       for(uint i=0; i<size; i++) {
+       for (uint i = 0; i < size; i++) {
                uint64_t val = s->getElement(i);
                if (val != cvalue)
                        elemArray[count++] = val;
@@@ -167,19 -167,19 +167,19 @@@
        solver->elemMap.put(var, var);
  
        if (count == 1) {
-               ElementConst * elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
+               ElementConst *elemconst = (ElementConst *) solver->getElementConst(s->type, elemArray[0]);
                replaceVarWithConst(pred, var, elemconst);
        }
  }
  
- void ElementOpt::replaceVarWithConst(BooleanPredicate * pred, ElementSet *var, ElementConst * value) {
+ void ElementOpt::replaceVarWithConst(BooleanPredicate *pred, ElementSet *var, ElementConst *value) {
        uint size = var->parents.getSize();
-       for(uint i=0; i < size; i++) {
-               ASTNode * parent = var->parents.get(i);
+       for (uint i = 0; i < size; i++) {
+               ASTNode *parent = var->parents.get(i);
                if (parent->type == PREDICATEOP && pred != parent) {
-                       BooleanPredicate * newpred = (BooleanPredicate *) parent;
-                       for(uint j=0; j < newpred->inputs.getSize(); j++) {
-                               Element * e = newpred->inputs.get(j);
+                       BooleanPredicate *newpred = (BooleanPredicate *) parent;
+                       for (uint j = 0; j < newpred->inputs.getSize(); j++) {
+                               Element *e = newpred->inputs.get(j);
                                if (e == var) {
                                        solver->boolMap.remove(newpred);
                                        newpred->inputs.set(j, value);

diff --combined src/Tuner/autotuner.cc
index e5ec2fb7839bf30c4749147a7202948f2963d19b,3b5f8ccf6441f47ff1297db3a3dca0a8f6434cea..ff3aa3f9f81b16b0ea368af69fbf94c72497e028
--- 1/src/Tuner/autotuner.cc
--- 2/src/Tuner/autotuner.cc
+++ b/src/Tuner/autotuner.cc
@@@ -18,14 -18,14 +18,14 @@@ void AutoTuner::addProblem(CSolver *sol
  long long AutoTuner::evaluate(CSolver *problem, SearchTuner *tuner) {
        CSolver *copy = problem->clone();
        copy->setTuner(tuner);
-         model_print("**********************\n");
+       model_print("**********************\n");
        int sat = copy->solve();
-         if(result == UNSETVALUE)
-                 result = sat;
-         else if(result != sat){
-                 model_print("&&&&&&&&&&&&&&&&&& Result has changed &&&&&&&&&&&&&\n");
-                 copy->printConstraints();
-         }
+       if (result == UNSETVALUE)
+               result = sat;
+       else if (result != sat) {
+               model_print("&&&&&&&&&&&&&&&&&& Result has changed &&&&&&&&&&&&&\n");
+               copy->printConstraints();
+       }
        //model_print("SAT %d\n", result);
        long long elapsedTime = copy->getElapsedTime();
  //    long long encodeTime = copy->getEncodeTime();
@@@ -102,7 -102,6 +102,7 @@@ void AutoTuner::tune() 
        }
        model_print("Best tuner:\n");
        bestTuner->print();
 +      bestTuner->serialize();
        model_print("Received score %f\n", bestScore);
        if (bestTuner != NULL)
                delete bestTuner;

diff --combined src/Tuner/tunable.cc
index e7c2d33cd77adbc3ad4f110281f0a203b348637e,6a74926901adb287d4f9893fc3a7f24f2d5c547c..a06d0f1290b888bcb0a167b86a2961a2c7ec1f21
--- 1/src/Tuner/tunable.cc
--- 2/src/Tuner/tunable.cc
+++ b/src/Tuner/tunable.cc
@@@ -15,35 -15,29 +15,35 @@@ int DefaultTuner::getVarTunable(VarTyp
        return descriptor->defaultValue;
  }
  
 -const char *tunableParameterToString(Tunables tunable) {
 -      switch (tunable) {
 -      case DECOMPOSEORDER:
 -              return "DECOMPOSEORDER";
 -      case MUSTREACHGLOBAL:
 -              return "MUSTREACHGLOBAL";
 -      case MUSTREACHLOCAL:
 -              return "MUSTREACHLOCAL";
 -      case MUSTREACHPRUNE:
 -              return "MUSTREACHPRUNE";
 -      case OPTIMIZEORDERSTRUCTURE:
 -              return "OPTIMIZEORDERSTRUCTURE";
 -      case ORDERINTEGERENCODING:
 -              return "ORDERINTEGERENCODING";
 -      case PREPROCESS:
 -              return "PREPROCESS";
 -      case NODEENCODING:
 -              return "NODEENCODING";
 -      case EDGEENCODING:
 -              return "EDGEENCODING";
 -      case MUSTEDGEPRUNE:
 -              return "MUSTEDGEPRUNE";
 -      default:
 -              ASSERT(0);
 -      }
 -}
 +const char* tunableParameterToString(Tunables tunable){
 +        switch(tunable){
 +                case DECOMPOSEORDER:
 +                        return "DECOMPOSEORDER";
 +                case MUSTREACHGLOBAL:
 +                        return "MUSTREACHGLOBAL";
 +                case MUSTREACHLOCAL:
 +                        return "MUSTREACHLOCAL";
 +                case MUSTREACHPRUNE:
 +                        return "MUSTREACHPRUNE";
 +                case OPTIMIZEORDERSTRUCTURE:
 +                        return "OPTIMIZEORDERSTRUCTURE";
 +                case ORDERINTEGERENCODING:
 +                        return "ORDERINTEGERENCODING";
 +                case PREPROCESS:
 +                        return "PREPROCESS";
 +                case NODEENCODING:
 +                        return "NODEENCODING";
 +                case EDGEENCODING:
 +                        return "EDGEENCODING";
 +                case MUSTEDGEPRUNE:
 +                        return "MUSTEDGEPRUNE";
 +              case ELEMENTOPT: 
 +                      return "ELEMENTOPT";
 +              case ELEMENTOPTSETS:
 +                      return "ELEMENTOPTSETS";
 +              case PROXYVARIABLE:
 +                      return "PROXYVARIABLE";
 +                default:
 +                        ASSERT(0);
 +        }
- }
++}