Changeset 2386 for trunk/Clp/src/OsiClp

Timestamp:

Jan 6, 2019 6:03:50 PM (2 years ago)

Author:

unxusr

Message:

formatting

Location:

trunk/Clp/src/OsiClp

Files:

• OsiClpSolverInterface.cpp (modified) (256 diffs)
• OsiClpSolverInterface.hpp (modified) (63 diffs)

trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

@@ -10 +10 @@
 extern int osi_dual;
 extern int osi_hot;
-#endif 
+#endif
 #include "CoinTime.hpp"
 #include "CoinHelperFunctions.hpp"
@@ -38 +38 @@
 //#define PRINT_TIME
 #ifdef PRINT_TIME
-static double totalTime=0.0;
+static double totalTime = 0.0;
 #endif
 //#define SAVE_MODEL 1
 #ifdef SAVE_MODEL
-static int resolveTry=0;
-static int loResolveTry=0;
-static int hiResolveTry=9999999;
+static int resolveTry = 0;
+static int loResolveTry = 0;
+static int hiResolveTry = 9999999;
 #endif
 //#############################################################################
@@ -54 +54 @@
 #ifdef KEEP_SMALL
   if (smallModel_) {
-    delete [] spareArrays_;
+    delete[] spareArrays_;
     spareArrays_ = NULL;
     delete smallModel_;
-    smallModel_=NULL;
-  }
-#endif
-  if ((specialOptions_&2097152)!=0||(specialOptions_&4194304)!=0) {
+    smallModel_ = NULL;
+  }
+#endif
+  if ((specialOptions_ & 2097152) != 0 || (specialOptions_ & 4194304) != 0) {
     bool takeHint;
     OsiHintStrength strength;
     int algorithm = 0;
-    getHintParam(OsiDoDualInInitial,takeHint,strength);
-    if (strength!=OsiHintIgnore)
+    getHintParam(OsiDoDualInInitial, takeHint, strength);
+    if (strength != OsiHintIgnore)
       algorithm = takeHint ? -1 : 1;
-    if (algorithm>0||(specialOptions_&4194304)!=0) {
+    if (algorithm > 0 || (specialOptions_ & 4194304) != 0) {
       // Gub
-      resolveGub((9*modelPtr_->numberRows())/10);
+      resolveGub((9 * modelPtr_->numberRows()) / 10);
       return;
     }
   }
   bool deleteSolver;
-  ClpSimplex * solver;
+  ClpSimplex *solver;
 #ifdef PRINT_TIME
   double time1 = CoinCpuTime();
 #endif
   int userFactorizationFrequency = modelPtr_->factorization()->maximumPivots();
-  int totalIterations=0;
-  bool abortSearch=false;
-  ClpObjective * savedObjective=NULL;
-  double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
+  int totalIterations = 0;
+  bool abortSearch = false;
+  ClpObjective *savedObjective = NULL;
+  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
   if (fakeObjective_) {
     // Clear (no objective, 0-1 and in B&B)
-    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
+    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
     // See if all with costs fixed
     int numberColumns = modelPtr_->numberColumns_;
-    const double * obj = modelPtr_->objective();
-    const double * lower = modelPtr_->columnLower();
-    const double * upper = modelPtr_->columnUpper();
+    const double *obj = modelPtr_->objective();
+    const double *lower = modelPtr_->columnLower();
+    const double *upper = modelPtr_->columnUpper();
     int i;
-    for (i=0;i<numberColumns;i++) {
+    for (i = 0; i < numberColumns; i++) {
       double objValue = obj[i];
       if (objValue) {
-        if (lower[i]!=upper[i])
-          break;
-      }
-    }
-    if (i==numberColumns) {
+        if (lower[i] != upper[i])
+          break;
+      }
+    }
+    if (i == numberColumns) {
       // Check (Clp fast dual)
-      if ((specialOptions_&524288)==0) {
-        // Set fake
-        savedObjective=modelPtr_->objective_;
-        modelPtr_->objective_=fakeObjective_;
-        modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
+      if ((specialOptions_ & 524288) == 0) {
+        // Set fake
+        savedObjective = modelPtr_->objective_;
+        modelPtr_->objective_ = fakeObjective_;
+        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
       } else {
-        // Set (no objective, 0-1 and in B&B)
-        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
+        // Set (no objective, 0-1 and in B&B)
+        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
       }
     }
   }
   // Check (in branch and bound)
-  if ((specialOptions_&1024)==0) {
+  if ((specialOptions_ & 1024) == 0) {
     solver = new ClpSimplex(true);
-    deleteSolver=true;
+    deleteSolver = true;
     solver->borrowModel(*modelPtr_);
     // See if user set factorization frequency
@@ -122 +122 @@
   } else {
     solver = modelPtr_;
-    deleteSolver=false;
+    deleteSolver = false;
   }
   // Treat as if user simplex not enabled
-  int saveSolveType=solver->solveType();
-  bool doingPrimal = solver->algorithm()>0;
-  if (saveSolveType==2) {
+  int saveSolveType = solver->solveType();
+  bool doingPrimal = solver->algorithm() > 0;
+  if (saveSolveType == 2) {
     disableSimplexInterface();
     solver->setSolveType(1);
   }
   int saveOptions = solver->specialOptions();
-  solver->setSpecialOptions(saveOptions|64|32768); // go as far as possible
+  solver->setSpecialOptions(saveOptions | 64 | 32768); // go as far as possible
   // get original log levels
-  int saveMessageLevel=modelPtr_->logLevel();
-  int messageLevel=messageHandler()->logLevel();
+  int saveMessageLevel = modelPtr_->logLevel();
+  int messageLevel = messageHandler()->logLevel();
   int saveMessageLevel2 = messageLevel;
   // Set message handler
@@ -146 +146 @@
   OsiHintStrength strength;
   // Switch off printing if asked to
-  bool gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
-  assert (gotHint);
-  if (strength!=OsiHintIgnore&&takeHint) {
-    if (messageLevel>0)
+  bool gotHint = (getHintParam(OsiDoReducePrint, takeHint, strength));
+  assert(gotHint);
+  if (strength != OsiHintIgnore && takeHint) {
+    if (messageLevel > 0)
       messageLevel--;
   }
-  if (messageLevel<saveMessageLevel)
+  if (messageLevel < saveMessageLevel)
     solver->messageHandler()->setLogLevel(messageLevel);
   // Allow for specialOptions_==1+8 forcing saving factorization
-  int startFinishOptions=0;
-  if ((specialOptions_&9)==(1+8)) {
-    startFinishOptions =1+2+4; // allow re-use of factorization
-  }
-  bool defaultHints=true;
+  int startFinishOptions = 0;
+  if ((specialOptions_ & 9) == (1 + 8)) {
+    startFinishOptions = 1 + 2 + 4; // allow re-use of factorization
+  }
+  bool defaultHints = true;
   {
     int hint;
-    for (hint=OsiDoPresolveInInitial;hint<OsiLastHintParam;hint++) {
-      if (hint!=OsiDoReducePrint&&
-          hint!=OsiDoInBranchAndCut) {
+    for (hint = OsiDoPresolveInInitial; hint < OsiLastHintParam; hint++) {
+      if (hint != OsiDoReducePrint && hint != OsiDoInBranchAndCut) {
         bool yesNo;
         OsiHintStrength strength;
-        getHintParam(static_cast<OsiHintParam> (hint),yesNo,strength);
+        getHintParam(static_cast< OsiHintParam >(hint), yesNo, strength);
         if (yesNo) {
-          defaultHints=false;
+          defaultHints = false;
           break;
         }
         if (strength != OsiHintIgnore) {
-          defaultHints=false;
+          defaultHints = false;
           break;
         }
@@ -179 +178 @@
     }
   }
-  ClpPresolve * pinfo = NULL;
+  ClpPresolve *pinfo = NULL;
   /*
     If basis then do primal (as user could do dual with resolve)
     If not then see if dual feasible (and allow for gubs etc?)
   */
-  bool doPrimal = (basis_.numberBasicStructurals()>0);
-  setBasis(basis_,solver);
-  bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
-  if ((!defaultHints||doPrimal)&&!solveOptions_.getSpecialOption(6)) {
+  bool doPrimal = (basis_.numberBasicStructurals() > 0);
+  setBasis(basis_, solver);
+  bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
+  if ((!defaultHints || doPrimal) && !solveOptions_.getSpecialOption(6)) {
     // scaling
     // save initial state
-    const double * rowScale1 = solver->rowScale();
-    if (modelPtr_->solveType()==1) {
-      gotHint = (getHintParam(OsiDoScale,takeHint,strength));
-      assert (gotHint);
-      if (strength==OsiHintIgnore||takeHint) {
+    const double *rowScale1 = solver->rowScale();
+    if (modelPtr_->solveType() == 1) {
+      gotHint = (getHintParam(OsiDoScale, takeHint, strength));
+      assert(gotHint);
+      if (strength == OsiHintIgnore || takeHint) {
         if (!solver->scalingFlag())
           solver->scaling(3);
@@ -205 +204 @@
     //solver->setDualBound(1.0e6);
     //solver->setDualTolerance(1.0e-7);
-    
+
     //ClpDualRowSteepest steep;
     //solver->setDualRowPivotAlgorithm(steep);
@@ -211 +210 @@
     //ClpPrimalColumnSteepest steepP;
     //solver->setPrimalColumnPivotAlgorithm(steepP);
-    
+
     // sort out hints;
     // algorithm 0 whatever, -1 force dual, +1 force primal
-    int algorithm = 0; 
-    gotHint = (getHintParam(OsiDoDualInInitial,takeHint,strength));
-    assert (gotHint);
-    if (strength!=OsiHintIgnore)
+    int algorithm = 0;
+    gotHint = (getHintParam(OsiDoDualInInitial, takeHint, strength));
+    assert(gotHint);
+    if (strength != OsiHintIgnore)
       algorithm = takeHint ? -1 : 1;
     // crash 0 do lightweight if all slack, 1 do, -1 don't
-    int doCrash=0;
-    gotHint = (getHintParam(OsiDoCrash,takeHint,strength));
-    assert (gotHint);
-    if (strength!=OsiHintIgnore)
+    int doCrash = 0;
+    gotHint = (getHintParam(OsiDoCrash, takeHint, strength));
+    assert(gotHint);
+    if (strength != OsiHintIgnore)
       doCrash = takeHint ? 1 : -1;
     // doPrimal set true if any structurals in basis so switch off crash
     if (doPrimal)
       doCrash = -1;
-    
+
     // presolve
-    gotHint = (getHintParam(OsiDoPresolveInInitial,takeHint,strength));
-    assert (gotHint);
-    if (strength!=OsiHintIgnore&&takeHint) {
+    gotHint = (getHintParam(OsiDoPresolveInInitial, takeHint, strength));
+    assert(gotHint);
+    if (strength != OsiHintIgnore && takeHint) {
       pinfo = new ClpPresolve();
-      ClpSimplex * model2 = pinfo->presolvedModel(*solver,1.0e-8);
+      ClpSimplex *model2 = pinfo->presolvedModel(*solver, 1.0e-8);
       if (!model2) {
         // problem found to be infeasible - whats best?
         model2 = solver;
-        delete pinfo;
-        pinfo = NULL;
+        delete pinfo;
+        pinfo = NULL;
       } else {
-        model2->setSpecialOptions(solver->specialOptions());
-      }
-      
+        model2->setSpecialOptions(solver->specialOptions());
+      }
+
       // change from 200 (unless changed)
-      if (modelPtr_->factorization()->maximumPivots()==200)
-        model2->factorization()->maximumPivots(100+model2->numberRows()/50);
+      if (modelPtr_->factorization()->maximumPivots() == 200)
+        model2->factorization()->maximumPivots(100 + model2->numberRows() / 50);
       else
         model2->factorization()->maximumPivots(userFactorizationFrequency);
       int savePerturbation = model2->perturbation();
-      if (savePerturbation==100)
+      if (savePerturbation == 100)
         model2->setPerturbation(50);
       if (!doPrimal) {
@@ -257 +256 @@
         model2->tightenPrimalBounds();
         // look further
-        bool crashResult=false;
-        if (doCrash>0)
-          crashResult =  (solver->crash(1000.0,1)>0);
-        else if (doCrash==0&&algorithm>0)
-          crashResult =  (solver->crash(1000.0,1)>0);
-        doPrimal=crashResult;
-      }
-      if (algorithm<0)
-        doPrimal=false;
-      else if (algorithm>0)
-        doPrimal=true;
+        bool crashResult = false;
+        if (doCrash > 0)
+          crashResult = (solver->crash(1000.0, 1) > 0);
+        else if (doCrash == 0 && algorithm > 0)
+          crashResult = (solver->crash(1000.0, 1) > 0);
+        doPrimal = crashResult;
+      }
+      if (algorithm < 0)
+        doPrimal = false;
+      else if (algorithm > 0)
+        doPrimal = true;
       if (!doPrimal) {
         //if (numberInfeasibilities)
@@ -274 +273 @@
         // up dual bound for safety
         //model2->setDualBound(1.0e11);
-        disasterHandler_->setOsiModel(this);
-        if (inCbcOrOther) {
-          disasterHandler_->setSimplex(model2);
-          disasterHandler_->setWhereFrom(4);
-          model2->setDisasterHandler(disasterHandler_);
-        }
+        disasterHandler_->setOsiModel(this);
+        if (inCbcOrOther) {
+          disasterHandler_->setSimplex(model2);
+          disasterHandler_->setWhereFrom(4);
+          model2->setDisasterHandler(disasterHandler_);
+        }
         model2->dual(0);
-        totalIterations += model2->numberIterations();
-        if (inCbcOrOther) {
-          if(disasterHandler_->inTrouble()) {
+        totalIterations += model2->numberIterations();
+        if (inCbcOrOther) {
+          if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-            printf("dual trouble a\n");
-#endif
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            // try just going back in
-            disasterHandler_->setPhase(1);
-            model2->dual();
-            totalIterations += model2->numberIterations();
-            if (disasterHandler_->inTrouble()) {
+            printf("dual trouble a\n");
+#endif
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            // try just going back in
+            disasterHandler_->setPhase(1);
+            model2->dual();
+            totalIterations += model2->numberIterations();
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("dual trouble b\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try primal with original basis
-              disasterHandler_->setPhase(2);
-              setBasis(basis_,model2);
-              model2->primal();
-              totalIterations += model2->numberIterations();
-            }
-            if(disasterHandler_->inTrouble()) {
+              printf("dual trouble b\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try primal with original basis
+              disasterHandler_->setPhase(2);
+              setBasis(basis_, model2);
+              model2->primal();
+              totalIterations += model2->numberIterations();
+            }
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("disaster - treat as infeasible\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              model2->setProblemStatus(1);
-            }
-          }
-          // reset
-          model2->setDisasterHandler(NULL);
-        }
+              printf("disaster - treat as infeasible\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              model2->setProblemStatus(1);
+            }
+          }
+          // reset
+          model2->setDisasterHandler(NULL);
+        }
         // check if clp thought it was in a loop
-        if (model2->status()==3&&!model2->hitMaximumIterations()) {
+        if (model2->status() == 3 && !model2->hitMaximumIterations()) {
           // switch algorithm
-          disasterHandler_->setOsiModel(this);
-          if (inCbcOrOther) {
-            disasterHandler_->setSimplex(model2);
-            disasterHandler_->setWhereFrom(6);
-            model2->setDisasterHandler(disasterHandler_);
-          }
+          disasterHandler_->setOsiModel(this);
+          if (inCbcOrOther) {
+            disasterHandler_->setSimplex(model2);
+            disasterHandler_->setWhereFrom(6);
+            model2->setDisasterHandler(disasterHandler_);
+          }
           model2->primal();
-          totalIterations += model2->numberIterations();
-          if (inCbcOrOther) {
-            if(disasterHandler_->inTrouble()) {
+          totalIterations += model2->numberIterations();
+          if (inCbcOrOther) {
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("primal trouble a\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try just going back in (but with dual)
-              disasterHandler_->setPhase(1);
-              model2->dual();
-              totalIterations += model2->numberIterations();
-              if (disasterHandler_->inTrouble()) {
+              printf("primal trouble a\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try just going back in (but with dual)
+              disasterHandler_->setPhase(1);
+              model2->dual();
+              totalIterations += model2->numberIterations();
+              if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                printf("primal trouble b\n");
-#endif
-                if (disasterHandler_->typeOfDisaster()) {
-                  // We want to abort 
-                  abortSearch=true;
-                  goto disaster;
-                }
-                // try primal with original basis
-                disasterHandler_->setPhase(2);
-                setBasis(basis_,model2);
-                model2->dual();
-                totalIterations += model2->numberIterations();
-              }
-              if(disasterHandler_->inTrouble()) {
+                printf("primal trouble b\n");
+#endif
+                if (disasterHandler_->typeOfDisaster()) {
+                  // We want to abort
+                  abortSearch = true;
+                  goto disaster;
+                }
+                // try primal with original basis
+                disasterHandler_->setPhase(2);
+                setBasis(basis_, model2);
+                model2->dual();
+                totalIterations += model2->numberIterations();
+              }
+              if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                printf("disaster - treat as infeasible\n");
-#endif
-                if (disasterHandler_->typeOfDisaster()) {
-                  // We want to abort 
-                  abortSearch=true;
-                  goto disaster;
-                }
-                model2->setProblemStatus(1);
-              }
-            }
-            // reset
-            model2->setDisasterHandler(NULL);
-          }
+                printf("disaster - treat as infeasible\n");
+#endif
+                if (disasterHandler_->typeOfDisaster()) {
+                  // We want to abort
+                  abortSearch = true;
+                  goto disaster;
+                }
+                model2->setProblemStatus(1);
+              }
+            }
+            // reset
+            model2->setDisasterHandler(NULL);
+          }
         }
       } else {
         // up infeasibility cost for safety
         //model2->setInfeasibilityCost(1.0e10);
-        disasterHandler_->setOsiModel(this);
-        if (inCbcOrOther) {
-          disasterHandler_->setSimplex(model2);
-          disasterHandler_->setWhereFrom(6);
-          model2->setDisasterHandler(disasterHandler_);
-        }
+        disasterHandler_->setOsiModel(this);
+        if (inCbcOrOther) {
+          disasterHandler_->setSimplex(model2);
+          disasterHandler_->setWhereFrom(6);
+          model2->setDisasterHandler(disasterHandler_);
+        }
         model2->primal(1);
-        totalIterations += model2->numberIterations();
-        if (inCbcOrOther) {
-          if(disasterHandler_->inTrouble()) {
+        totalIterations += model2->numberIterations();
+        if (inCbcOrOther) {
+          if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-            printf("primal trouble a\n");
-#endif
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            // try just going back in (but with dual)
-            disasterHandler_->setPhase(1);
-            model2->dual();
-            totalIterations += model2->numberIterations();
-            if (disasterHandler_->inTrouble()) {
+            printf("primal trouble a\n");
+#endif
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            // try just going back in (but with dual)
+            disasterHandler_->setPhase(1);
+            model2->dual();
+            totalIterations += model2->numberIterations();
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("primal trouble b\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try primal with original basis
-              disasterHandler_->setPhase(2);
-              setBasis(basis_,model2);
-              model2->dual();
-              totalIterations += model2->numberIterations();
-            }
-            if(disasterHandler_->inTrouble()) {
+              printf("primal trouble b\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try primal with original basis
+              disasterHandler_->setPhase(2);
+              setBasis(basis_, model2);
+              model2->dual();
+              totalIterations += model2->numberIterations();
+            }
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("disaster - treat as infeasible\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              model2->setProblemStatus(1);
-            }
-          }
-          // reset
-          model2->setDisasterHandler(NULL);
-        }
+              printf("disaster - treat as infeasible\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              model2->setProblemStatus(1);
+            }
+          }
+          // reset
+          model2->setDisasterHandler(NULL);
+        }
         // check if clp thought it was in a loop
-        if (model2->status()==3&&!model2->hitMaximumIterations()) {
+        if (model2->status() == 3 && !model2->hitMaximumIterations()) {
           // switch algorithm
-          disasterHandler_->setOsiModel(this);
-          if (inCbcOrOther) {
-            disasterHandler_->setSimplex(model2);
-            disasterHandler_->setWhereFrom(4);
-            model2->setDisasterHandler(disasterHandler_);
-          }
-          model2->dual(0);
-          totalIterations += model2->numberIterations();
-          if (inCbcOrOther) {
-            if(disasterHandler_->inTrouble()) {
+          disasterHandler_->setOsiModel(this);
+          if (inCbcOrOther) {
+            disasterHandler_->setSimplex(model2);
+            disasterHandler_->setWhereFrom(4);
+            model2->setDisasterHandler(disasterHandler_);
+          }
+          model2->dual(0);
+          totalIterations += model2->numberIterations();
+          if (inCbcOrOther) {
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("dual trouble a\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try just going back in
-              disasterHandler_->setPhase(1);
-              model2->dual();
-              totalIterations += model2->numberIterations();
-              if (disasterHandler_->inTrouble()) {
+              printf("dual trouble a\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try just going back in
+              disasterHandler_->setPhase(1);
+              model2->dual();
+              totalIterations += model2->numberIterations();
+              if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                printf("dual trouble b\n");
-#endif
-                if (disasterHandler_->typeOfDisaster()) {
-                  // We want to abort 
-                  abortSearch=true;
-                goto disaster;
-                }
-                // try primal with original basis
-                disasterHandler_->setPhase(2);
-                setBasis(basis_,model2);
-                model2->primal();
-                totalIterations += model2->numberIterations();
-              }
-              if(disasterHandler_->inTrouble()) {
+                printf("dual trouble b\n");
+#endif
+                if (disasterHandler_->typeOfDisaster()) {
+                  // We want to abort
+                  abortSearch = true;
+                  goto disaster;
+                }
+                // try primal with original basis
+                disasterHandler_->setPhase(2);
+                setBasis(basis_, model2);
+                model2->primal();
+                totalIterations += model2->numberIterations();
+              }
+              if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                printf("disaster - treat as infeasible\n");
-#endif
-                if (disasterHandler_->typeOfDisaster()) {
-                  // We want to abort 
-                  abortSearch=true;
-                  goto disaster;
-                }
-                model2->setProblemStatus(1);
-              }
-            }
-            // reset
-            model2->setDisasterHandler(NULL);
-          }
+                printf("disaster - treat as infeasible\n");
+#endif
+                if (disasterHandler_->typeOfDisaster()) {
+                  // We want to abort
+                  abortSearch = true;
+                  goto disaster;
+                }
+                model2->setProblemStatus(1);
+              }
+            }
+            // reset
+            model2->setDisasterHandler(NULL);
+          }
         }
       }
       model2->setPerturbation(savePerturbation);
-      if (model2!=solver) {
+      if (model2 != solver) {
         int presolvedStatus = model2->status();
         pinfo->postsolve(true);
-        delete pinfo;
-        pinfo = NULL;
-        
+        delete pinfo;
+        pinfo = NULL;
+
         delete model2;
-        int oldStatus=solver->status();
-        solver->setProblemStatus(presolvedStatus);
-        if (solver->logLevel()==63) // for gcc 4.6 bug
-          printf("pstat %d stat %d\n",presolvedStatus,oldStatus);
+        int oldStatus = solver->status();
+        solver->setProblemStatus(presolvedStatus);
+        if (solver->logLevel() == 63) // for gcc 4.6 bug
+          printf("pstat %d stat %d\n", presolvedStatus, oldStatus);
         //printf("Resolving from postsolved model\n");
         // later try without (1) and check duals before solve
-        if (presolvedStatus!=3
-            &&(presolvedStatus||oldStatus==-1)) {
-          if (!inCbcOrOther||presolvedStatus!=1) {
-            disasterHandler_->setOsiModel(this);
-            if (inCbcOrOther) {
-              disasterHandler_->setSimplex(solver); // as "borrowed"
-              disasterHandler_->setWhereFrom(6);
-              solver->setDisasterHandler(disasterHandler_);
-            }
-            solver->primal(1);
-            totalIterations += solver->numberIterations();
-            if (inCbcOrOther) {
-              if(disasterHandler_->inTrouble()) {
+        if (presolvedStatus != 3
+          && (presolvedStatus || oldStatus == -1)) {
+          if (!inCbcOrOther || presolvedStatus != 1) {
+            disasterHandler_->setOsiModel(this);
+            if (inCbcOrOther) {
+              disasterHandler_->setSimplex(solver); // as "borrowed"
+              disasterHandler_->setWhereFrom(6);
+              solver->setDisasterHandler(disasterHandler_);
+            }
+            solver->primal(1);
+            totalIterations += solver->numberIterations();
+            if (inCbcOrOther) {
+              if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                printf("primal trouble a\n");
-#endif
-                if (disasterHandler_->typeOfDisaster()) {
-                  // We want to abort 
-                  abortSearch=true;
-                  goto disaster;
-                }
-                // try just going back in (but with dual)
-                disasterHandler_->setPhase(1);
-                solver->dual();
-                totalIterations += solver->numberIterations();
-                if (disasterHandler_->inTrouble()) {
+                printf("primal trouble a\n");
+#endif
+                if (disasterHandler_->typeOfDisaster()) {
+                  // We want to abort
+                  abortSearch = true;
+                  goto disaster;
+                }
+                // try just going back in (but with dual)
+                disasterHandler_->setPhase(1);
+                solver->dual();
+                totalIterations += solver->numberIterations();
+                if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                  printf("primal trouble b\n");
-#endif
-                  if (disasterHandler_->typeOfDisaster()) {
-                    // We want to abort 
-                    abortSearch=true;
-                    goto disaster;
-                  }
-                  // try primal with original basis
-                  disasterHandler_->setPhase(2);
-                  setBasis(basis_,solver);
-                  solver->dual();
-                  totalIterations += solver->numberIterations();
-                }
-                if(disasterHandler_->inTrouble()) {
+                  printf("primal trouble b\n");
+#endif
+                  if (disasterHandler_->typeOfDisaster()) {
+                    // We want to abort
+                    abortSearch = true;
+                    goto disaster;
+                  }
+                  // try primal with original basis
+                  disasterHandler_->setPhase(2);
+                  setBasis(basis_, solver);
+                  solver->dual();
+                  totalIterations += solver->numberIterations();
+                }
+                if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-                  printf("disaster - treat as infeasible\n");
-#endif
-                  if (disasterHandler_->typeOfDisaster()) {
-                    // We want to abort 
-                    abortSearch=true;
-                    goto disaster;
-                  }
-                  solver->setProblemStatus(1);
-                }
-              }
-              // reset
-              solver->setDisasterHandler(NULL);
-            }
-          }
-        }
-      }
-      lastAlgorithm_=1; // primal
+                  printf("disaster - treat as infeasible\n");
+#endif
+                  if (disasterHandler_->typeOfDisaster()) {
+                    // We want to abort
+                    abortSearch = true;
+                    goto disaster;
+                  }
+                  solver->setProblemStatus(1);
+                }
+              }
+              // reset
+              solver->setDisasterHandler(NULL);
+            }
+          }
+        }
+      }
+      lastAlgorithm_ = 1; // primal
       //if (solver->numberIterations())
       //printf("****** iterated %d\n",solver->numberIterations());
     } else {
       // do we want crash
-      if (doCrash>0)
-        solver->crash(1000.0,2);
-      else if (doCrash==0)
-        solver->crash(1000.0,0);
-      if (algorithm<0)
-        doPrimal=false;
-      else if (algorithm>0)
-        doPrimal=true;
+      if (doCrash > 0)
+        solver->crash(1000.0, 2);
+      else if (doCrash == 0)
+        solver->crash(1000.0, 0);
+      if (algorithm < 0)
+        doPrimal = false;
+      else if (algorithm > 0)
+        doPrimal = true;
       disasterHandler_->setOsiModel(this);
       disasterHandler_->setSimplex(solver); // as "borrowed"
-      bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
-      if (!doPrimal) 
-        disasterHandler_->setWhereFrom(4);
+      bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
+      if (!doPrimal)
+        disasterHandler_->setWhereFrom(4);
       else
-        disasterHandler_->setWhereFrom(6);
+        disasterHandler_->setWhereFrom(6);
       if (inCbcOrOther)
-        solver->setDisasterHandler(disasterHandler_);
+        solver->setDisasterHandler(disasterHandler_);
       if (!doPrimal) {
         //printf("doing dual\n");
         solver->dual(0);
-        totalIterations += solver->numberIterations();
-        if (inCbcOrOther) {
-          if(disasterHandler_->inTrouble()) {
+        totalIterations += solver->numberIterations();
+        if (inCbcOrOther) {
+          if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-            printf("dual trouble a\n");
-#endif
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            // try just going back in
-            disasterHandler_->setPhase(1);
-            solver->dual();
-            totalIterations += solver->numberIterations();
-            if (disasterHandler_->inTrouble()) {
+            printf("dual trouble a\n");
+#endif
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            // try just going back in
+            disasterHandler_->setPhase(1);
+            solver->dual();
+            totalIterations += solver->numberIterations();
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("dual trouble b\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try primal with original basis
-              disasterHandler_->setPhase(2);
-              setBasis(basis_,solver);
-              solver->primal();
-              totalIterations += solver->numberIterations();
-            }
-            if(disasterHandler_->inTrouble()) {
+              printf("dual trouble b\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try primal with original basis
+              disasterHandler_->setPhase(2);
+              setBasis(basis_, solver);
+              solver->primal();
+              totalIterations += solver->numberIterations();
+            }
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("disaster - treat as infeasible\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              solver->setProblemStatus(1);
-            }
-          }
-          // reset
-          solver->setDisasterHandler(NULL);
-        }
-        lastAlgorithm_=2; // dual
+              printf("disaster - treat as infeasible\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              solver->setProblemStatus(1);
+            }
+          }
+          // reset
+          solver->setDisasterHandler(NULL);
+        }
+        lastAlgorithm_ = 2; // dual
         // check if clp thought it was in a loop
-        if (solver->status()==3&&!solver->hitMaximumIterations()) {
+        if (solver->status() == 3 && !solver->hitMaximumIterations()) {
           // switch algorithm
           solver->primal(0);
-          totalIterations += solver->numberIterations();
-          lastAlgorithm_=1; // primal
+          totalIterations += solver->numberIterations();
+          lastAlgorithm_ = 1; // primal
         }
       } else {
         //printf("doing primal\n");
         solver->primal(1);
-        totalIterations += solver->numberIterations();
-        if (inCbcOrOther) {
-          if(disasterHandler_->inTrouble()) {
+        totalIterations += solver->numberIterations();
+        if (inCbcOrOther) {
+          if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-            printf("primal trouble a\n");
-#endif
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            // try just going back in (but with dual)
-            disasterHandler_->setPhase(1);
-            solver->dual();
-            totalIterations += solver->numberIterations();
-            if (disasterHandler_->inTrouble()) {
+            printf("primal trouble a\n");
+#endif
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            // try just going back in (but with dual)
+            disasterHandler_->setPhase(1);
+            solver->dual();
+            totalIterations += solver->numberIterations();
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("primal trouble b\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              // try primal with original basis
-              disasterHandler_->setPhase(2);
-              setBasis(basis_,solver);
-              solver->dual();
-              totalIterations += solver->numberIterations();
-            }
-            if(disasterHandler_->inTrouble()) {
+              printf("primal trouble b\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              // try primal with original basis
+              disasterHandler_->setPhase(2);
+              setBasis(basis_, solver);
+              solver->dual();
+              totalIterations += solver->numberIterations();
+            }
+            if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-              printf("disaster - treat as infeasible\n");
-#endif
-              if (disasterHandler_->typeOfDisaster()) {
-                // We want to abort 
-                abortSearch=true;
-                goto disaster;
-              }
-              solver->setProblemStatus(1);
-            }
-          }
-          // reset
-          solver->setDisasterHandler(NULL);
-        }
-        lastAlgorithm_=1; // primal
+              printf("disaster - treat as infeasible\n");
+#endif
+              if (disasterHandler_->typeOfDisaster()) {
+                // We want to abort
+                abortSearch = true;
+                goto disaster;
+              }
+              solver->setProblemStatus(1);
+            }
+          }
+          // reset
+          solver->setDisasterHandler(NULL);
+        }
+        lastAlgorithm_ = 1; // primal
         // check if clp thought it was in a loop
-        if (solver->status()==3&&!solver->hitMaximumIterations()) {
+        if (solver->status() == 3 && !solver->hitMaximumIterations()) {
           // switch algorithm
           solver->dual(0);
-          totalIterations += solver->numberIterations();
-          lastAlgorithm_=2; // dual
+          totalIterations += solver->numberIterations();
+          lastAlgorithm_ = 2; // dual
         }
       }
     }
     // If scaled feasible but unscaled infeasible take action
-    if (!solver->status()&&cleanupScaling_) {
+    if (!solver->status() && cleanupScaling_) {
       solver->cleanup(cleanupScaling_);
     }
     basis_ = getBasis(solver);
     //basis_.print();
-    const double * rowScale2 = solver->rowScale();
+    const double *rowScale2 = solver->rowScale();
     solver->setSpecialOptions(saveOptions);
-    if (!rowScale1&&rowScale2) {
+    if (!rowScale1 && rowScale2) {
       // need to release memory
       if (!solver->savedRowScale_) {
-        solver->setRowScale(NULL);
-        solver->setColumnScale(NULL);
+        solver->setRowScale(NULL);
+        solver->setColumnScale(NULL);
       } else {
-        solver->rowScale_=NULL;
-        solver->columnScale_=NULL;
+        solver->rowScale_ = NULL;
+        solver->columnScale_ = NULL;
       }
     }
   } else {
     // User doing nothing and all slack basis
-    ClpSolve options=solveOptions_;
+    ClpSolve options = solveOptions_;
     bool yesNo;
     OsiHintStrength strength;
-    getHintParam(OsiDoInBranchAndCut,yesNo,strength);
+    getHintParam(OsiDoInBranchAndCut, yesNo, strength);
     if (yesNo) {
-      solver->setSpecialOptions(solver->specialOptions()|1024);
+      solver->setSpecialOptions(solver->specialOptions() | 1024);
     }
     solver->initialSolve(options);
@@ -733 +732 @@
     lastAlgorithm_ = 2; // say dual
     // If scaled feasible but unscaled infeasible take action
-    if (!solver->status()&&cleanupScaling_) {
+    if (!solver->status() && cleanupScaling_) {
       solver->cleanup(cleanupScaling_);
     }
@@ -740 +739 @@
   }
   solver->messageHandler()->setLogLevel(saveMessageLevel);
- disaster:
+disaster:
   if (deleteSolver) {
     solver->returnModel(*modelPtr_);
@@ -747 +746 @@
   if (startFinishOptions) {
     int save = modelPtr_->logLevel();
-    if (save<2) modelPtr_->setLogLevel(0);
-    modelPtr_->dual(0,startFinishOptions);
+    if (save < 2)
+      modelPtr_->setLogLevel(0);
+    modelPtr_->dual(0, startFinishOptions);
     totalIterations += modelPtr_->numberIterations();
     modelPtr_->setLogLevel(save);
   }
-  if (saveSolveType==2) {
+  if (saveSolveType == 2) {
     enableSimplexInterface(doingPrimal);
   }
   if (savedObjective) {
     // fix up
-    modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
+    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-    modelPtr_->objective_=savedObjective;
+    modelPtr_->objective_ = savedObjective;
     if (!modelPtr_->problemStatus_) {
-      CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-      CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-      if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-        CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
       modelPtr_->computeObjectiveValue();
     }
@@ -770 +770 @@
   modelPtr_->setNumberIterations(totalIterations);
   handler_->setLogLevel(saveMessageLevel2);
-  if (modelPtr_->problemStatus_==3&&lastAlgorithm_==2)
+  if (modelPtr_->problemStatus_ == 3 && lastAlgorithm_ == 2)
     modelPtr_->computeObjectiveValue();
   // mark so we can pick up objective value quickly
-  modelPtr_->upperIn_=0.0;
+  modelPtr_->upperIn_ = 0.0;
 #ifdef PRINT_TIME
-  time1 = CoinCpuTime()-time1;
+  time1 = CoinCpuTime() - time1;
   totalTime += time1;
 #endif
-  assert (!modelPtr_->disasterHandler());
-  if (lastAlgorithm_<1||lastAlgorithm_>2)
-    lastAlgorithm_=1;
+  assert(!modelPtr_->disasterHandler());
+  if (lastAlgorithm_ < 1 || lastAlgorithm_ > 2)
+    lastAlgorithm_ = 1;
   if (abortSearch) {
-    lastAlgorithm_=-911;
+    lastAlgorithm_ = -911;
     modelPtr_->setProblemStatus(4);
   }
@@ -794 +794 @@
 #endif
 #ifdef PRINT_TIME
-  std::cout<<time1<<" seconds - total "<<totalTime<<std::endl;
+  std::cout << time1 << " seconds - total " << totalTime << std::endl;
 #endif
   delete pinfo;
@@ -805 +805 @@
     int i;
     int n = getNumCols();
-    const double *lower = getColLower() ;
-    const double *upper = getColUpper() ;
-    for (i=0;i<n;i++) {
-      assert (lower[i]<1.0e12);
-      assert (upper[i]>-1.0e12);
+    const double *lower = getColLower();
+    const double *upper = getColUpper();
+    for (i = 0; i < n; i++) {
+      assert(lower[i] < 1.0e12);
+      assert(upper[i] > -1.0e12);
     }
     n = getNumRows();
-    lower = getRowLower() ;
-    upper = getRowUpper() ;
-    for (i=0;i<n;i++) {
-      assert (lower[i]<1.0e12);
-      assert (upper[i]>-1.0e12);
-    }
-  }
-#endif
-  if ((stuff_.solverOptions_&65536)!=0) {
+    lower = getRowLower();
+    upper = getRowUpper();
+    for (i = 0; i < n; i++) {
+      assert(lower[i] < 1.0e12);
+      assert(upper[i] > -1.0e12);
+    }
+  }
+#endif
+  if ((stuff_.solverOptions_ & 65536) != 0) {
     modelPtr_->fastDual2(&stuff_);
     return;
   }
-  if ((specialOptions_&2097152)!=0||(specialOptions_&4194304)!=0) {
+  if ((specialOptions_ & 2097152) != 0 || (specialOptions_ & 4194304) != 0) {
     bool takeHint;
     OsiHintStrength strength;
     int algorithm = 0;
-    getHintParam(OsiDoDualInResolve,takeHint,strength);
-    if (strength!=OsiHintIgnore)
+    getHintParam(OsiDoDualInResolve, takeHint, strength);
+    if (strength != OsiHintIgnore)
       algorithm = takeHint ? -1 : 1;
-    if (algorithm>0||(specialOptions_&4194304)!=0) {
+    if (algorithm > 0 || (specialOptions_ & 4194304) != 0) {
       // Gub
-      resolveGub((9*modelPtr_->numberRows())/10);
+      resolveGub((9 * modelPtr_->numberRows()) / 10);
       return;
     }
@@ -841 +841 @@
   bool takeHint;
   OsiHintStrength strength;
-  bool gotHint = (getHintParam(OsiDoInBranchAndCut,takeHint,strength));
-  assert (gotHint);
+  bool gotHint = (getHintParam(OsiDoInBranchAndCut, takeHint, strength));
+  assert(gotHint);
   // mark so we can pick up objective value quickly
-  modelPtr_->upperIn_=0.0;
-  if ((specialOptions_&4096)!=0) {
+  modelPtr_->upperIn_ = 0.0;
+  if ((specialOptions_ & 4096) != 0) {
     // Quick check to see if optimal
     modelPtr_->checkSolutionInternal();
-    if (modelPtr_->problemStatus()==0) {
+    if (modelPtr_->problemStatus() == 0) {
       modelPtr_->setNumberIterations(0);
       return;
     }
   }
-  int totalIterations=0;
-  bool abortSearch=false;
-  ClpObjective * savedObjective=NULL;
-  double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
+  int totalIterations = 0;
+  bool abortSearch = false;
+  ClpObjective *savedObjective = NULL;
+  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
   if (fakeObjective_) {
-    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
+    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
     // See if all with costs fixed
     int numberColumns = modelPtr_->numberColumns_;
-    const double * obj = modelPtr_->objective();
-    const double * lower = modelPtr_->columnLower();
-    const double * upper = modelPtr_->columnUpper();
+    const double *obj = modelPtr_->objective();
+    const double *lower = modelPtr_->columnLower();
+    const double *upper = modelPtr_->columnUpper();
     int i;
-    for (i=0;i<numberColumns;i++) {
+    for (i = 0; i < numberColumns; i++) {
       double objValue = obj[i];
       if (objValue) {
-        if (lower[i]!=upper[i])
-          break;
-      }
-    }
-    if (i==numberColumns) {
-      if ((specialOptions_&524288)==0) {
-        // Set fake
-        savedObjective=modelPtr_->objective_;
-        modelPtr_->objective_=fakeObjective_;
-        modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
+        if (lower[i] != upper[i])
+          break;
+      }
+    }
+    if (i == numberColumns) {
+      if ((specialOptions_ & 524288) == 0) {
+        // Set fake
+        savedObjective = modelPtr_->objective_;
+        modelPtr_->objective_ = fakeObjective_;
+        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
       } else {
-        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
+        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
       }
     }
   }
   // If using Clp initialSolve and primal - just do here
-  gotHint = (getHintParam(OsiDoDualInResolve,takeHint,strength));
-  assert (gotHint);
-  if (strength!=OsiHintIgnore&&!takeHint&&solveOptions_.getSpecialOption(6)) {
-    ClpSolve options=solveOptions_;
+  gotHint = (getHintParam(OsiDoDualInResolve, takeHint, strength));
+  assert(gotHint);
+  if (strength != OsiHintIgnore && !takeHint && solveOptions_.getSpecialOption(6)) {
+    ClpSolve options = solveOptions_;
     // presolve
-    getHintParam(OsiDoPresolveInResolve,takeHint,strength);
-    if (strength!=OsiHintIgnore&&!takeHint)
+    getHintParam(OsiDoPresolveInResolve, takeHint, strength);
+    if (strength != OsiHintIgnore && !takeHint)
       options.setPresolveType(ClpSolve::presolveOff);
     int saveOptions = modelPtr_->specialOptions();
-    getHintParam(OsiDoInBranchAndCut,takeHint,strength);
+    getHintParam(OsiDoInBranchAndCut, takeHint, strength);
     if (takeHint) {
-      modelPtr_->setSpecialOptions(modelPtr_->specialOptions()|1024);
-    }
-    setBasis(basis_,modelPtr_);
+      modelPtr_->setSpecialOptions(modelPtr_->specialOptions() | 1024);
+    }
+    setBasis(basis_, modelPtr_);
     modelPtr_->initialSolve(options);
     lastAlgorithm_ = 1; // say primal
     // If scaled feasible but unscaled infeasible take action
-    if (!modelPtr_->status()&&cleanupScaling_) {
+    if (!modelPtr_->status() && cleanupScaling_) {
       modelPtr_->cleanup(cleanupScaling_);
     }
@@ -907 +907 @@
     basis_ = getBasis(modelPtr_);
   }
-  int saveSolveType=modelPtr_->solveType();
-  bool doingPrimal = modelPtr_->algorithm()>0;
-  if (saveSolveType==2) {
+  int saveSolveType = modelPtr_->solveType();
+  bool doingPrimal = modelPtr_->algorithm() > 0;
+  if (saveSolveType == 2) {
     disableSimplexInterface();
   }
   int saveOptions = modelPtr_->specialOptions();
-  int startFinishOptions=0;
-  if (specialOptions_!=0x80000000) {
-    if((specialOptions_&1)==0) {
-      startFinishOptions=0;
-      modelPtr_->setSpecialOptions(saveOptions|(64|1024|32768));
+  int startFinishOptions = 0;
+  if (specialOptions_ != 0x80000000) {
+    if ((specialOptions_ & 1) == 0) {
+      startFinishOptions = 0;
+      modelPtr_->setSpecialOptions(saveOptions | (64 | 1024 | 32768));
     } else {
-      startFinishOptions=1+4;
-      if ((specialOptions_&8)!=0)
-        startFinishOptions +=2; // allow re-use of factorization
-      if((specialOptions_&4)==0||!takeHint) 
-        modelPtr_->setSpecialOptions(saveOptions|(64|128|512|1024|4096|32768));
+      startFinishOptions = 1 + 4;
+      if ((specialOptions_ & 8) != 0)
+        startFinishOptions += 2; // allow re-use of factorization
+      if ((specialOptions_ & 4) == 0 || !takeHint)
+        modelPtr_->setSpecialOptions(saveOptions | (64 | 128 | 512 | 1024 | 4096 | 32768));
       else
-        modelPtr_->setSpecialOptions(saveOptions|(64|128|512|1024|2048|4096|32768));
+        modelPtr_->setSpecialOptions(saveOptions | (64 | 128 | 512 | 1024 | 2048 | 4096 | 32768));
     }
   } else {
-    modelPtr_->setSpecialOptions(saveOptions|64|32768);
+    modelPtr_->setSpecialOptions(saveOptions | 64 | 32768);
   }
   //printf("options %d size %d\n",modelPtr_->specialOptions(),modelPtr_->numberColumns());
   //modelPtr_->setSolveType(1);
   // Set message handler to have same levels etc
-  int saveMessageLevel=modelPtr_->logLevel();
-  int messageLevel=messageHandler()->logLevel();
+  int saveMessageLevel = modelPtr_->logLevel();
+  int messageLevel = messageHandler()->logLevel();
   bool oldDefault;
-  CoinMessageHandler * saveHandler = NULL;
+  CoinMessageHandler *saveHandler = NULL;
   if (!defaultHandler_)
-    saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
+    saveHandler = modelPtr_->pushMessageHandler(handler_, oldDefault);
   //printf("basis before dual\n");
   //basis_.print();
-  setBasis(basis_,modelPtr_);
+  setBasis(basis_, modelPtr_);
 #ifdef SAVE_MODEL
   resolveTry++;
 #if SAVE_MODEL > 1
-  if (resolveTry>=loResolveTry&&
-      resolveTry<=hiResolveTry) {
+  if (resolveTry >= loResolveTry && resolveTry <= hiResolveTry) {
     char fileName[20];
-    sprintf(fileName,"save%d.mod",resolveTry);
+    sprintf(fileName, "save%d.mod", resolveTry);
     modelPtr_->saveModel(fileName);
   }
@@ -955 +954 @@
   // set reasonable defaults
   // Switch off printing if asked to
-  gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
-  assert (gotHint);
-  if (strength!=OsiHintIgnore&&takeHint) {
-    if (messageLevel>0)
+  gotHint = (getHintParam(OsiDoReducePrint, takeHint, strength));
+  assert(gotHint);
+  if (strength != OsiHintIgnore && takeHint) {
+    if (messageLevel > 0)
       messageLevel--;
   }
-  if (messageLevel<modelPtr_->messageHandler()->logLevel())
+  if (messageLevel < modelPtr_->messageHandler()->logLevel())
     modelPtr_->messageHandler()->setLogLevel(messageLevel);
   // See if user set factorization frequency
   int userFactorizationFrequency = modelPtr_->factorization()->maximumPivots();
   // scaling
-  if (modelPtr_->solveType()==1) {
-    gotHint = (getHintParam(OsiDoScale,takeHint,strength));
-    assert (gotHint);
-    if (strength==OsiHintIgnore||takeHint) {
+  if (modelPtr_->solveType() == 1) {
+    gotHint = (getHintParam(OsiDoScale, takeHint, strength));
+    assert(gotHint);
+    if (strength == OsiHintIgnore || takeHint) {
       if (!modelPtr_->scalingFlag())
-        modelPtr_->scaling(3);
+        modelPtr_->scaling(3);
     } else {
       modelPtr_->scaling(0);
@@ -981 +980 @@
   // algorithm -1 force dual, +1 force primal
   int algorithm = -1;
-  gotHint = (getHintParam(OsiDoDualInResolve,takeHint,strength));
-  assert (gotHint);
-  if (strength!=OsiHintIgnore)
+  gotHint = (getHintParam(OsiDoDualInResolve, takeHint, strength));
+  assert(gotHint);
+  if (strength != OsiHintIgnore)
     algorithm = takeHint ? -1 : 1;
   //modelPtr_->saveModel("save.bad");
   // presolve
-  gotHint = (getHintParam(OsiDoPresolveInResolve,takeHint,strength));
-  assert (gotHint);
-  if (strength!=OsiHintIgnore&&takeHint) {
+  gotHint = (getHintParam(OsiDoPresolveInResolve, takeHint, strength));
+  assert(gotHint);
+  if (strength != OsiHintIgnore && takeHint) {
 #ifdef KEEP_SMALL
     if (smallModel_) {
-      delete [] spareArrays_;
+      delete[] spareArrays_;
       spareArrays_ = NULL;
       delete smallModel_;
-      smallModel_=NULL;
+      smallModel_ = NULL;
     }
 #endif
     ClpPresolve pinfo;
-    if ((specialOptions_&128)!=0) {
+    if ((specialOptions_ & 128) != 0) {
       specialOptions_ &= ~128;
     }
-    if ((modelPtr_->specialOptions()&1024)!=0) {
+    if ((modelPtr_->specialOptions() & 1024) != 0) {
       pinfo.setDoDual(false);
       pinfo.setDoTripleton(false);
@@ -1009 +1008 @@
       pinfo.setDoSingletonColumn(false);
     }
-    ClpSimplex * model2 = pinfo.presolvedModel(*modelPtr_,1.0e-8);
+    ClpSimplex *model2 = pinfo.presolvedModel(*modelPtr_, 1.0e-8);
     if (!model2) {
       // problem found to be infeasible - whats best?
@@ -1015 +1014 @@
     }
     // return number of rows
-    int * stats = reinterpret_cast<int *> (getApplicationData());
+    int *stats = reinterpret_cast< int * >(getApplicationData());
     if (stats) {
-      stats[0]=model2->numberRows();
-      stats[1]=model2->numberColumns();
+      stats[0] = model2->numberRows();
+      stats[1] = model2->numberColumns();
     }
     //printf("rows %d -> %d, columns %d -> %d\n",
@@ -1024 +1023 @@
     //     modelPtr_->numberColumns(),model2->numberColumns());
     // change from 200
-    if (modelPtr_->factorization()->maximumPivots()==200)
-      model2->factorization()->maximumPivots(100+model2->numberRows()/50);
+    if (modelPtr_->factorization()->maximumPivots() == 200)
+      model2->factorization()->maximumPivots(100 + model2->numberRows() / 50);
     else
       model2->factorization()->maximumPivots(userFactorizationFrequency);
-    if (algorithm<0) {
+    if (algorithm < 0) {
       model2->dual();
       totalIterations += model2->numberIterations();
       // check if clp thought it was in a loop
-      if (model2->status()==3&&!model2->hitMaximumIterations()) {
-        // switch algorithm
-        model2->primal();
-        totalIterations += model2->numberIterations();
+      if (model2->status() == 3 && !model2->hitMaximumIterations()) {
+        // switch algorithm
+        model2->primal();
+        totalIterations += model2->numberIterations();
       }
     } else {
@@ -1041 +1040 @@
       totalIterations += model2->numberIterations();
       // check if clp thought it was in a loop
-      if (model2->status()==3&&!model2->hitMaximumIterations()) {
-        // switch algorithm
-        model2->dual();
-        totalIterations += model2->numberIterations();
-      }
-    }
-    if (model2!=modelPtr_) {
-      int finalStatus=model2->status();
+      if (model2->status() == 3 && !model2->hitMaximumIterations()) {
+        // switch algorithm
+        model2->dual();
+        totalIterations += model2->numberIterations();
+      }
+    }
+    if (model2 != modelPtr_) {
+      int finalStatus = model2->status();
       pinfo.postsolve(true);
-    
+
       delete model2;
       // later try without (1) and check duals before solve
-      if (finalStatus!=3&&(finalStatus||modelPtr_->status()==-1)) {
+      if (finalStatus != 3 && (finalStatus || modelPtr_->status() == -1)) {
         modelPtr_->primal(1);
-        totalIterations += modelPtr_->numberIterations();
-        lastAlgorithm_=1; // primal
+        totalIterations += modelPtr_->numberIterations();
+        lastAlgorithm_ = 1; // primal
         //if (modelPtr_->numberIterations())
         //printf("****** iterated %d\n",modelPtr_->numberIterations());
@@ -1064 +1063 @@
     //modelPtr_->setLogLevel(63);
     //modelPtr_->setDualTolerance(1.0e-7);
-    if (false&&modelPtr_->scalingFlag_>0&&!modelPtr_->rowScale_&&
-        !modelPtr_->rowCopy_&&matrixByRow_) {
-      assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
+    if (false && modelPtr_->scalingFlag_ > 0 && !modelPtr_->rowScale_ && !modelPtr_->rowCopy_ && matrixByRow_) {
+      assert(matrixByRow_->getNumElements() == modelPtr_->clpMatrix()->getNumElements());
       modelPtr_->setNewRowCopy(new ClpPackedMatrix(*matrixByRow_));
     }
-    if (algorithm<0) {
+    if (algorithm < 0) {
       //writeMps("try1");
       int savePerturbation = modelPtr_->perturbation();
-      if ((specialOptions_&2)!=0)
-        modelPtr_->setPerturbation(100);
+      if ((specialOptions_ & 2) != 0)
+        modelPtr_->setPerturbation(100);
       //modelPtr_->messageHandler()->setLogLevel(1);
       //writeMpsNative("bad",NULL,NULL,2,1,1.0);
       disasterHandler_->setOsiModel(this);
-      bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
+      bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
 #if 0
       // See how many integers fixed
@@ -1100 +1098 @@
       }
 #endif
-      if((specialOptions_&1)==0||
-         (specialOptions_&2048)!=0||
-         (modelPtr_->specialOptions_&2097152)!=0/*||skipCrunch*/) {
-        disasterHandler_->setWhereFrom(0); // dual
-        if (inCbcOrOther)
-          modelPtr_->setDisasterHandler(disasterHandler_);
-        bool specialScale;
-        if ((specialOptions_&131072)!=0&&!modelPtr_->rowScale_) {
-          modelPtr_->rowScale_ = rowScale_.array();
-          modelPtr_->columnScale_ = columnScale_.array();
-          specialScale=true;
-        } else {
-          specialScale=false;
-        }
+      if ((specialOptions_ & 1) == 0 || (specialOptions_ & 2048) != 0 || (modelPtr_->specialOptions_ & 2097152) != 0 /*||skipCrunch*/) {
+        disasterHandler_->setWhereFrom(0); // dual
+        if (inCbcOrOther)
+          modelPtr_->setDisasterHandler(disasterHandler_);
+        bool specialScale;
+        if ((specialOptions_ & 131072) != 0 && !modelPtr_->rowScale_) {
+          modelPtr_->rowScale_ = rowScale_.array();
+          modelPtr_->columnScale_ = columnScale_.array();
+          specialScale = true;
+        } else {
+          specialScale = false;
+        }
 #ifdef KEEP_SMALL
-        if (smallModel_) {
-          delete [] spareArrays_;
-          spareArrays_ = NULL;
-          delete smallModel_;
-          smallModel_=NULL;
-        }
+        if (smallModel_) {
+          delete[] spareArrays_;
+          spareArrays_ = NULL;
+          delete smallModel_;
+          smallModel_ = NULL;
+        }
 #endif
 #ifdef CBC_STATISTICS
-        osi_dual++;
-#endif 
-        modelPtr_->dual(0,startFinishOptions);
-        totalIterations += modelPtr_->numberIterations();
-        if (specialScale) {
-          modelPtr_->rowScale_ = NULL;
-          modelPtr_->columnScale_ = NULL;
-        }
+        osi_dual++;
+#endif
+        modelPtr_->dual(0, startFinishOptions);
+        totalIterations += modelPtr_->numberIterations();
+        if (specialScale) {
+          modelPtr_->rowScale_ = NULL;
+          modelPtr_->columnScale_ = NULL;
+        }
       } else {
 #ifdef CBC_STATISTICS
-        osi_crunch++;
-#endif 
-        crunch();
-        totalIterations += modelPtr_->numberIterations();
-        if (modelPtr_->problemStatus()==4)
-          goto disaster;
-        // should have already been fixed if problems
-        inCbcOrOther=false;
+        osi_crunch++;
+#endif
+        crunch();
+        totalIterations += modelPtr_->numberIterations();
+        if (modelPtr_->problemStatus() == 4)
+          goto disaster;
+        // should have already been fixed if problems
+        inCbcOrOther = false;
       }
       if (inCbcOrOther) {
-        if(disasterHandler_->inTrouble()) {
-          if (disasterHandler_->typeOfDisaster()) {
-            // We want to abort 
-            abortSearch=true;
-            goto disaster;
-          }
-          // try just going back in
-          disasterHandler_->setPhase(1);
-          modelPtr_->dual();
-          totalIterations += modelPtr_->numberIterations();
-          if (disasterHandler_->inTrouble()) {
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            // try primal with original basis
-            disasterHandler_->setPhase(2);
-            setBasis(basis_,modelPtr_);
-            modelPtr_->primal();
-            totalIterations += modelPtr_->numberIterations();
-          }
-          if(disasterHandler_->inTrouble()) {
+        if (disasterHandler_->inTrouble()) {
+          if (disasterHandler_->typeOfDisaster()) {
+            // We want to abort
+            abortSearch = true;
+            goto disaster;
+          }
+          // try just going back in
+          disasterHandler_->setPhase(1);
+          modelPtr_->dual();
+          totalIterations += modelPtr_->numberIterations();
+          if (disasterHandler_->inTrouble()) {
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            // try primal with original basis
+            disasterHandler_->setPhase(2);
+            setBasis(basis_, modelPtr_);
+            modelPtr_->primal();
+            totalIterations += modelPtr_->numberIterations();
+          }
+          if (disasterHandler_->inTrouble()) {
 #ifdef COIN_DEVELOP
-            printf("disaster - treat as infeasible\n");
-#endif
-            if (disasterHandler_->typeOfDisaster()) {
-              // We want to abort 
-              abortSearch=true;
-              goto disaster;
-            }
-            modelPtr_->setProblemStatus(1);
-          }
-        }
-        // reset
-        modelPtr_->setDisasterHandler(NULL);
-      }
-      if (modelPtr_->problemStatus()==4) {
-        // bad bounds?
-        modelPtr_->setProblemStatus(1);
-      }
-      if (!modelPtr_->problemStatus()&&0) {
+            printf("disaster - treat as infeasible\n");
+#endif
+            if (disasterHandler_->typeOfDisaster()) {
+              // We want to abort
+              abortSearch = true;
+              goto disaster;
+            }
+            modelPtr_->setProblemStatus(1);
+          }
+        }
+        // reset
+        modelPtr_->setDisasterHandler(NULL);
+      }
+      if (modelPtr_->problemStatus() == 4) {
+        // bad bounds?
+        modelPtr_->setProblemStatus(1);
+      }
+      if (!modelPtr_->problemStatus() && 0) {
         int numberColumns = modelPtr_->numberColumns();
-        const double * columnLower = modelPtr_->columnLower();
-        const double * columnUpper = modelPtr_->columnUpper();
-        int nBad=0;
-        for (int i=0;i<numberColumns;i++) {
-          if (columnLower[i]==columnUpper[i]&&modelPtr_->getColumnStatus(i)==ClpSimplex::basic) {
+        const double *columnLower = modelPtr_->columnLower();
+        const double *columnUpper = modelPtr_->columnUpper();
+        int nBad = 0;
+        for (int i = 0; i < numberColumns; i++) {
+          if (columnLower[i] == columnUpper[i] && modelPtr_->getColumnStatus(i) == ClpSimplex::basic) {
             nBad++;
-            modelPtr_->setColumnStatus(i,ClpSimplex::isFixed);
+            modelPtr_->setColumnStatus(i, ClpSimplex::isFixed);
           }
         }
         if (nBad) {
           modelPtr_->primal(1);
-    totalIterations += modelPtr_->numberIterations();
-          printf("%d fixed basic - %d iterations\n",nBad,modelPtr_->numberIterations());
+          totalIterations += modelPtr_->numberIterations();
+          printf("%d fixed basic - %d iterations\n", nBad, modelPtr_->numberIterations());
         }
       }
-      assert (modelPtr_->objectiveValue()<1.0e100);
+      assert(modelPtr_->objectiveValue() < 1.0e100);
       modelPtr_->setPerturbation(savePerturbation);
-      lastAlgorithm_=2; // dual
+      lastAlgorithm_ = 2; // dual
       // check if clp thought it was in a loop
-      if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
-        modelPtr_->setSpecialOptions(saveOptions);
-        // switch algorithm
-        //modelPtr_->messageHandler()->setLogLevel(63);
-        // Allow for catastrophe
-        int saveMax = modelPtr_->maximumIterations();
-        int numberIterations = modelPtr_->numberIterations();
-        int numberRows = modelPtr_->numberRows();
-        int numberColumns = modelPtr_->numberColumns();
-        if (modelPtr_->maximumIterations()>100000+numberIterations)
-          modelPtr_->setMaximumIterations(numberIterations + 1000 + 2*numberRows+numberColumns);
-        modelPtr_->primal(0,startFinishOptions);
-        totalIterations += modelPtr_->numberIterations();
-        modelPtr_->setMaximumIterations(saveMax);
-        lastAlgorithm_=1; // primal
-        if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
+      if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
+        modelPtr_->setSpecialOptions(saveOptions);
+        // switch algorithm
+        //modelPtr_->messageHandler()->setLogLevel(63);
+        // Allow for catastrophe
+        int saveMax = modelPtr_->maximumIterations();
+        int numberIterations = modelPtr_->numberIterations();
+        int numberRows = modelPtr_->numberRows();
+        int numberColumns = modelPtr_->numberColumns();
+        if (modelPtr_->maximumIterations() > 100000 + numberIterations)
+          modelPtr_->setMaximumIterations(numberIterations + 1000 + 2 * numberRows + numberColumns);
+        modelPtr_->primal(0, startFinishOptions);
+        totalIterations += modelPtr_->numberIterations();
+        modelPtr_->setMaximumIterations(saveMax);
+        lastAlgorithm_ = 1; // primal
+        if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
 #ifdef COIN_DEVELOP
-          printf("in trouble - try all slack\n");
-#endif
-          CoinWarmStartBasis allSlack;
-          setBasis(allSlack,modelPtr_);
-          modelPtr_->dual();
-          totalIterations += modelPtr_->numberIterations();
-          if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
-            if (modelPtr_->numberPrimalInfeasibilities()) {
+          printf("in trouble - try all slack\n");
+#endif
+          CoinWarmStartBasis allSlack;
+          setBasis(allSlack, modelPtr_);
+          modelPtr_->dual();
+          totalIterations += modelPtr_->numberIterations();
+          if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
+            if (modelPtr_->numberPrimalInfeasibilities()) {
 #ifdef COIN_DEVELOP
-              printf("Real real trouble - treat as infeasible\n");
-#endif
-              modelPtr_->setProblemStatus(1);
-            } else {
+              printf("Real real trouble - treat as infeasible\n");
+#endif
+              modelPtr_->setProblemStatus(1);
+            } else {
 #ifdef COIN_DEVELOP
-              printf("Real real trouble - treat as optimal\n");
-#endif
-              modelPtr_->setProblemStatus(0);
-            }
-          }
-        }
-      }
-      assert (modelPtr_->objectiveValue()<1.0e100);
+              printf("Real real trouble - treat as optimal\n");
+#endif
+              modelPtr_->setProblemStatus(0);
+            }
+          }
+        }
+      }
+      assert(modelPtr_->objectiveValue() < 1.0e100);
     } else {
 #ifdef KEEP_SMALL
       if (smallModel_) {
-        delete [] spareArrays_;
-        spareArrays_ = NULL;
-        delete smallModel_;
-        smallModel_=NULL;
+        delete[] spareArrays_;
+        spareArrays_ = NULL;
+        delete smallModel_;
+        smallModel_ = NULL;
       }
 #endif
@@ -1256 +1252 @@
 #ifdef CBC_STATISTICS
       osi_primal++;
-#endif 
-      modelPtr_->primal(1,startFinishOptions);
+#endif
+      modelPtr_->primal(1, startFinishOptions);
       totalIterations += modelPtr_->numberIterations();
-      lastAlgorithm_=1; // primal
+      lastAlgorithm_ = 1; // primal
       // check if clp thought it was in a loop
-      if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
-        // switch algorithm
-        modelPtr_->dual();
-        totalIterations += modelPtr_->numberIterations();
-        lastAlgorithm_=2; // dual
+      if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
+        // switch algorithm
+        modelPtr_->dual();
+        totalIterations += modelPtr_->numberIterations();
+        lastAlgorithm_ = 2; // dual
       }
     }
@@ -1275 +1271 @@
   }
   basis_ = getBasis(modelPtr_);
- disaster:
+disaster:
   //printf("basis after dual\n");
   //basis_.print();
   if (!defaultHandler_)
-    modelPtr_->popMessageHandler(saveHandler,oldDefault);
+    modelPtr_->popMessageHandler(saveHandler, oldDefault);
   modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
-  if (saveSolveType==2) {
+  if (saveSolveType == 2) {
     int saveStatus = modelPtr_->problemStatus_;
     enableSimplexInterface(doingPrimal);
-    modelPtr_->problemStatus_=saveStatus;
+    modelPtr_->problemStatus_ = saveStatus;
   }
 #ifdef COIN_DEVELOP_x
@@ -1290 +1286 @@
   if (doingDoneBranch) {
     if (modelPtr_->numberIterations())
-      printf("***** done %d iterations after general\n",modelPtr_->numberIterations());
-    doingDoneBranch=false;
+      printf("***** done %d iterations after general\n", modelPtr_->numberIterations());
+    doingDoneBranch = false;
   }
 #endif
@@ -1297 +1293 @@
   //modelPtr_->setSolveType(saveSolveType);
   if (abortSearch) {
-    lastAlgorithm_=-911;
+    lastAlgorithm_ = -911;
     modelPtr_->setProblemStatus(4);
   }
   if (savedObjective) {
     // fix up
-    modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
+    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-    modelPtr_->objective_=savedObjective;
+    modelPtr_->objective_ = savedObjective;
     if (!modelPtr_->problemStatus_) {
-      CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-      CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-      if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-        CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
       modelPtr_->computeObjectiveValue();
     }
   }
   modelPtr_->setSpecialOptions(saveOptions); // restore
-  if (modelPtr_->problemStatus_==3&&lastAlgorithm_==2)
+  if (modelPtr_->problemStatus_ == 3 && lastAlgorithm_ == 2)
     modelPtr_->computeObjectiveValue();
-  if (lastAlgorithm_<1||lastAlgorithm_>2)
-    lastAlgorithm_=1;
+  if (lastAlgorithm_ < 1 || lastAlgorithm_ > 2)
+    lastAlgorithm_ = 1;
 #ifdef SAVE_MODEL
-  if (resolveTry>=loResolveTry&&
-      resolveTry<=hiResolveTry) {
-    printf("resolve %d took %d iterations - algorithm %d\n",resolveTry,modelPtr_->numberIterations(),lastAlgorithm_);
+  if (resolveTry >= loResolveTry && resolveTry <= hiResolveTry) {
+    printf("resolve %d took %d iterations - algorithm %d\n", resolveTry, modelPtr_->numberIterations(), lastAlgorithm_);
   }
 #endif
@@ -1331 +1326 @@
 #include "ClpSimplexOther.hpp"
 // Resolve an LP relaxation after problem modification (try GUB)
-void 
-OsiClpSolverInterface::resolveGub(int needed)
+void OsiClpSolverInterface::resolveGub(int needed)
 {
   bool takeHint;
   OsiHintStrength strength;
   // Switch off printing if asked to
-  getHintParam(OsiDoReducePrint,takeHint,strength);
-  int saveMessageLevel=modelPtr_->logLevel();
-  if (strength!=OsiHintIgnore&&takeHint) {
-    int messageLevel=messageHandler()->logLevel();
-    if (messageLevel>0)
-      modelPtr_->messageHandler()->setLogLevel(messageLevel-1);
+  getHintParam(OsiDoReducePrint, takeHint, strength);
+  int saveMessageLevel = modelPtr_->logLevel();
+  if (strength != OsiHintIgnore && takeHint) {
+    int messageLevel = messageHandler()->logLevel();
+    if (messageLevel > 0)
+      modelPtr_->messageHandler()->setLogLevel(messageLevel - 1);
     else
       modelPtr_->messageHandler()->setLogLevel(0);
   }
   //modelPtr_->messageHandler()->setLogLevel(1);
-  setBasis(basis_,modelPtr_);
+  setBasis(basis_, modelPtr_);
   // find gub
   int numberRows = modelPtr_->numberRows();
-  int * which = new int[numberRows];
+  int *which = new int[numberRows];
   int numberColumns = modelPtr_->numberColumns();
-  int * whichC = new int[numberColumns+numberRows];
-  ClpSimplex * model2 = 
-    static_cast<ClpSimplexOther *> (modelPtr_)->gubVersion(which,whichC,
-                                                           needed,100);
+  int *whichC = new int[numberColumns + numberRows];
+  ClpSimplex *model2 = static_cast< ClpSimplexOther * >(modelPtr_)->gubVersion(which, whichC,
+    needed, 100);
   if (model2) {
     // move in solution
-    static_cast<ClpSimplexOther *> (model2)->setGubBasis(*modelPtr_,
-                                                         which,whichC);
-    model2->setLogLevel(CoinMin(1,model2->logLevel()));
+    static_cast< ClpSimplexOther * >(model2)->setGubBasis(*modelPtr_,
+      which, whichC);
+    model2->setLogLevel(CoinMin(1, model2->logLevel()));
     ClpPrimalColumnSteepest steepest(5);
     model2->setPrimalColumnPivotAlgorithm(steepest);
@@ -1366 +1359 @@
     model2->primal();
     //printf("Primal took %g seconds\n",CoinCpuTime()-time1);
-    static_cast<ClpSimplexOther *> (model2)->getGubBasis(*modelPtr_,
-                                                         which,whichC);
+    static_cast< ClpSimplexOther * >(model2)->getGubBasis(*modelPtr_,
+      which, whichC);
     int totalIterations = model2->numberIterations();
     delete model2;
     //modelPtr_->setLogLevel(63);
     modelPtr_->primal(1);
-    modelPtr_->setNumberIterations(totalIterations+modelPtr_->numberIterations());
+    modelPtr_->setNumberIterations(totalIterations + modelPtr_->numberIterations());
   } else {
     modelPtr_->dual();
   }
-  delete [] which;
-  delete [] whichC;
+  delete[] which;
+  delete[] whichC;
   basis_ = getBasis(modelPtr_);
   modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
 }
 // Sort of lexicographic resolve
-void 
-OsiClpSolverInterface::lexSolve()
+void OsiClpSolverInterface::lexSolve()
 {
 #if 1
   abort();
 #else
-  ((ClpSimplexPrimal *) modelPtr_)->lexSolve();
-  printf("itA %d\n",modelPtr_->numberIterations());
+  ((ClpSimplexPrimal *)modelPtr_)->lexSolve();
+  printf("itA %d\n", modelPtr_->numberIterations());
   modelPtr_->primal();
-  printf("itB %d\n",modelPtr_->numberIterations());
+  printf("itB %d\n", modelPtr_->numberIterations());
   basis_ = getBasis(modelPtr_);
 #endif
@@ -1411 +1403 @@
                1 leaves
   */
-void 
-OsiClpSolverInterface::setupForRepeatedUse(int senseOfAdventure, int printOut)
+void OsiClpSolverInterface::setupForRepeatedUse(int senseOfAdventure, int printOut)
 {
   // First try
   switch (senseOfAdventure) {
   case 0:
-    specialOptions_=8;
+    specialOptions_ = 8;
     break;
   case 1:
-    specialOptions_=1+2+8;
+    specialOptions_ = 1 + 2 + 8;
     break;
   case 2:
-    specialOptions_=1+2+4+8;
+    specialOptions_ = 1 + 2 + 4 + 8;
     break;
   case 3:
-    specialOptions_=1+8;
+    specialOptions_ = 1 + 8;
     break;
   }
@@ -1433 +1424 @@
   specialOptions_ &= ~1;
 #endif
-  bool stopPrinting=false;
-  if (printOut<0) {
-    stopPrinting=true;
+  bool stopPrinting = false;
+  if (printOut < 0) {
+    stopPrinting = true;
   } else if (!printOut) {
     bool takeHint;
     OsiHintStrength strength;
-    getHintParam(OsiDoReducePrint,takeHint,strength);
-    int messageLevel=messageHandler()->logLevel();
-    if (strength!=OsiHintIgnore&&takeHint) 
+    getHintParam(OsiDoReducePrint, takeHint, strength);
+    int messageLevel = messageHandler()->logLevel();
+    if (strength != OsiHintIgnore && takeHint)
       messageLevel--;
-    stopPrinting = (messageLevel<=0);
+    stopPrinting = (messageLevel <= 0);
   }
 #ifndef COIN_DEVELOP
   if (stopPrinting) {
-    CoinMessages * messagesPointer = modelPtr_->messagesPointer();
-    // won't even build messages 
-    messagesPointer->setDetailMessages(100,10000,reinterpret_cast<int *> (NULL));
+    CoinMessages *messagesPointer = modelPtr_->messagesPointer();
+    // won't even build messages
+    messagesPointer->setDetailMessages(100, 10000, reinterpret_cast< int * >(NULL));
   }
 #endif
@@ -1457 +1448 @@
 // only called in debug mode
 static void indexError(int index,
-                        std::string methodName)
-{
-  std::cerr<<"Illegal index "<<index<<" in OsiClpSolverInterface::"<<methodName<<std::endl;
-  throw CoinError("Illegal index",methodName,"OsiClpSolverInterface");
+  std::string methodName)
+{
+  std::cerr << "Illegal index " << index << " in OsiClpSolverInterface::" << methodName << std::endl;
+  throw CoinError("Illegal index", methodName, "OsiClpSolverInterface");
 }
 #endif
@@ -1467 +1458 @@
 //#############################################################################
 
-bool
-OsiClpSolverInterface::setIntParam(OsiIntParam key, int value)
-{
-  return modelPtr_->setIntParam(static_cast<ClpIntParam> (key), value);
+bool OsiClpSolverInterface::setIntParam(OsiIntParam key, int value)
+{
+  return modelPtr_->setIntParam(static_cast< ClpIntParam >(key), value);
 }
 
 //-----------------------------------------------------------------------------
 
-bool
-OsiClpSolverInterface::setDblParam(OsiDblParam key, double value)
-{
-  if (key != OsiLastDblParam ) {
-    if (key==OsiDualObjectiveLimit||key==OsiPrimalObjectiveLimit)
+bool OsiClpSolverInterface::setDblParam(OsiDblParam key, double value)
+{
+  if (key != OsiLastDblParam) {
+    if (key == OsiDualObjectiveLimit || key == OsiPrimalObjectiveLimit)
       value *= modelPtr_->optimizationDirection();
-    return modelPtr_->setDblParam(static_cast<ClpDblParam> (key), value);
+    return modelPtr_->setDblParam(static_cast< ClpDblParam >(key), value);
   } else {
     return false;
@@ -1489 +1478 @@
 //-----------------------------------------------------------------------------
 
-bool
-OsiClpSolverInterface::setStrParam(OsiStrParam key, const std::string & value)
-{
-  assert (key!=OsiSolverName);
-  if (key != OsiLastStrParam ) {
-    return modelPtr_->setStrParam(static_cast<ClpStrParam> (key), value);
+bool OsiClpSolverInterface::setStrParam(OsiStrParam key, const std::string &value)
+{
+  assert(key != OsiSolverName);
+  if (key != OsiLastStrParam) {
+    return modelPtr_->setStrParam(static_cast< ClpStrParam >(key), value);
   } else {
     return false;
@@ -1500 +1488 @@
 }
 
-
 //-----------------------------------------------------------------------------
 
-bool
-OsiClpSolverInterface::getIntParam(OsiIntParam key, int& value) const 
-{
-  return modelPtr_->getIntParam(static_cast<ClpIntParam> (key), value);
+bool OsiClpSolverInterface::getIntParam(OsiIntParam key, int &value) const
+{
+  return modelPtr_->getIntParam(static_cast< ClpIntParam >(key), value);
 }
 
 //-----------------------------------------------------------------------------
 
-bool
-OsiClpSolverInterface::getDblParam(OsiDblParam key, double& value) const
-{
-  if (key != OsiLastDblParam ) {
-    bool condition =  modelPtr_->getDblParam(static_cast<ClpDblParam> (key), value);
-    if (key==OsiDualObjectiveLimit||key==OsiPrimalObjectiveLimit)
+bool OsiClpSolverInterface::getDblParam(OsiDblParam key, double &value) const
+{
+  if (key != OsiLastDblParam) {
+    bool condition = modelPtr_->getDblParam(static_cast< ClpDblParam >(key), value);
+    if (key == OsiDualObjectiveLimit || key == OsiPrimalObjectiveLimit)
       value *= modelPtr_->optimizationDirection();
     return condition;
@@ -1526 +1511 @@
 //-----------------------------------------------------------------------------
 
-bool
-OsiClpSolverInterface::getStrParam(OsiStrParam key, std::string & value) const
-{
-  if ( key==OsiSolverName ) {
+bool OsiClpSolverInterface::getStrParam(OsiStrParam key, std::string &value) const
+{
+  if (key == OsiSolverName) {
     value = "clp";
     return true;
   }
-  if (key != OsiLastStrParam ) {
-    return modelPtr_->getStrParam(static_cast<ClpStrParam> (key), value);
+  if (key != OsiLastStrParam) {
+    return modelPtr_->getStrParam(static_cast< ClpStrParam >(key), value);
   } else {
     return false;
   }
 }
-
 
 //#############################################################################
@@ -1548 +1531 @@
 {
   // not sure about -1 (should not happen)
-  return (modelPtr_->status()==4||modelPtr_->status()==-1||
-          (modelPtr_->status()==1&&modelPtr_->secondaryStatus()==8));
+  return (modelPtr_->status() == 4 || modelPtr_->status() == -1 || (modelPtr_->status() == 1 && modelPtr_->secondaryStatus() == 8));
 }
 
@@ -1564 +1546 @@
   const int stat = modelPtr_->status();
   if (stat != 1)
-     return false;
+    return false;
   return true;
 }
@@ -1585 +1567 @@
     return false;
   }
-   
+
   const double obj = modelPtr_->objectiveValue();
-  int maxmin = static_cast<int> (modelPtr_->optimizationDirection());
+  int maxmin = static_cast< int >(modelPtr_->optimizationDirection());
 
   switch (lastAlgorithm_) {
-   case 0: // no simplex was needed
-     return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
-   case 2: // dual simplex
-     if (modelPtr_->status() == 0) // optimal
-        return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
-     return false;
-   case 1: // primal simplex
-     return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
+  case 0: // no simplex was needed
+    return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
+  case 2: // dual simplex
+    if (modelPtr_->status() == 0) // optimal
+      return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
+    return false;
+  case 1: // primal simplex
+    return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
   }
   return false; // fake return
@@ -1608 +1590 @@
   if (stat == 1)
     return true;
-  else if (stat<0)
+  else if (stat < 0)
     return false;
   double limit = 0.0;
@@ -1616 +1598 @@
     return false;
   }
-   
+
   const double obj = modelPtr_->objectiveValue();
-  int maxmin = static_cast<int> (modelPtr_->optimizationDirection());
+  int maxmin = static_cast< int >(modelPtr_->optimizationDirection());
 
   switch (lastAlgorithm_) {
-   case 0: // no simplex was needed
-     return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
-   case 1: // primal simplex
-     if (stat == 0) // optimal
-        return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
-     return false;
-   case 2: // dual simplex
-     if (stat != 0 && stat != 3)
-        // over dual limit
-        return true;
-     return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
+  case 0: // no simplex was needed
+    return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
+  case 1: // primal simplex
+    if (stat == 0) // optimal
+      return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
+    return false;
+  case 2: // dual simplex
+    if (stat != 0 && stat != 3)
+      // over dual limit
+      return true;
+    return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
   }
   return false; // fake return
@@ -1646 +1628 @@
 // WarmStart related methods
 //#############################################################################
-CoinWarmStart *OsiClpSolverInterface::getEmptyWarmStart () const
-  { return (static_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
-
-CoinWarmStart* OsiClpSolverInterface::getWarmStart() const
+CoinWarmStart *OsiClpSolverInterface::getEmptyWarmStart() const
+{
+  return (static_cast< CoinWarmStart * >(new CoinWarmStartBasis()));
+}
+
+CoinWarmStart *OsiClpSolverInterface::getWarmStart() const
 {
 
@@ -1662 +1646 @@
    OsiClp version always returns pointer and false.
 */
-CoinWarmStart* 
-OsiClpSolverInterface::getPointerToWarmStart(bool & mustDelete) 
+CoinWarmStart *
+OsiClpSolverInterface::getPointerToWarmStart(bool &mustDelete)
 {
   mustDelete = false;
@@ -1671 +1655 @@
 //-----------------------------------------------------------------------------
 
-bool OsiClpSolverInterface::setWarmStart(const CoinWarmStart* warmstart)
+bool OsiClpSolverInterface::setWarmStart(const CoinWarmStart *warmstart)
 {
   modelPtr_->whatsChanged_ &= 0xffff;
-  const CoinWarmStartBasis* ws =
-    dynamic_cast<const CoinWarmStartBasis*>(warmstart);
+  const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(warmstart);
   if (ws) {
     basis_ = CoinWarmStartBasis(*ws);
@@ -1695 +1678 @@
 #ifdef CBC_STATISTICS
   osi_hot++;
-#endif 
+#endif
   //printf("HotStart options %x changed %x, small %x spare %x\n",
   // specialOptions_,modelPtr_->whatsChanged_,
   // smallModel_,spareArrays_);
   modelPtr_->setProblemStatus(0);
-  saveData_.perturbation_=0;
+  saveData_.perturbation_ = 0;
   saveData_.specialOptions_ = modelPtr_->specialOptions_;
   modelPtr_->specialOptions_ |= 0x1000000;
-  modelPtr_->specialOptions_ = saveData_.specialOptions_; 
-  ClpObjective * savedObjective=NULL;
-  double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
+  modelPtr_->specialOptions_ = saveData_.specialOptions_;
+  ClpObjective *savedObjective = NULL;
+  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
   if (fakeObjective_) {
-    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
+    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
     // See if all with costs fixed
     int numberColumns = modelPtr_->numberColumns_;
-    const double * obj = modelPtr_->objective();
-    const double * lower = modelPtr_->columnLower();
-    const double * upper = modelPtr_->columnUpper();
+    const double *obj = modelPtr_->objective();
+    const double *lower = modelPtr_->columnLower();
+    const double *upper = modelPtr_->columnUpper();
     int i;
-    for (i=0;i<numberColumns;i++) {
+    for (i = 0; i < numberColumns; i++) {
       double objValue = obj[i];
       if (objValue) {
-        if (lower[i]!=upper[i])
-          break;
-      }
-    }
-    if (i==numberColumns) {
-      if ((specialOptions_&524288)==0) {
-        // Set fake
-        savedObjective=modelPtr_->objective_;
-        modelPtr_->objective_=fakeObjective_;
-        modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
-        saveData_.perturbation_=1;
+        if (lower[i] != upper[i])
+          break;
+      }
+    }
+    if (i == numberColumns) {
+      if ((specialOptions_ & 524288) == 0) {
+        // Set fake
+        savedObjective = modelPtr_->objective_;
+        modelPtr_->objective_ = fakeObjective_;
+        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
+        saveData_.perturbation_ = 1;
       } else {
-        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
+        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
       }
     }
@@ -1735 +1718 @@
 #define CLEAN_HOT_START
 #ifdef CLEAN_HOT_START
-  if ((specialOptions_&65536)!=0) {
+  if ((specialOptions_ & 65536) != 0) {
     //specialOptions_ |= 65536;
-    saveData_.scalingFlag_=modelPtr_->logLevel();
-    if (modelPtr_->logLevel()<2)
+    saveData_.scalingFlag_ = modelPtr_->logLevel();
+    if (modelPtr_->logLevel() < 2)
       modelPtr_->setLogLevel(0);
-    assert ((specialOptions_&128)==0);
+    assert((specialOptions_ & 128) == 0);
     // space for save arrays
     int numberColumns = modelPtr_->numberColumns();
     int numberRows = modelPtr_->numberRows();
-    // Get space for strong branching 
-    int size = static_cast<int>((1+4*(numberRows+numberColumns))*sizeof(double));
+    // Get space for strong branching
+    int size = static_cast< int >((1 + 4 * (numberRows + numberColumns)) * sizeof(double));
     // and for save of original column bounds
-    size += static_cast<int>(2*numberColumns*sizeof(double));
-    size += static_cast<int>((1+4*numberRows+2*numberColumns)*sizeof(int));
-    size += numberRows+numberColumns;
-    assert (spareArrays_==NULL);
+    size += static_cast< int >(2 * numberColumns * sizeof(double));
+    size += static_cast< int >((1 + 4 * numberRows + 2 * numberColumns) * sizeof(int));
+    size += numberRows + numberColumns;
+    assert(spareArrays_ == NULL);
     spareArrays_ = new char[size];
     //memset(spareArrays_,0x20,size);
     // Setup for strong branching
-    assert (factorization_==NULL);
-    if ((specialOptions_&131072)!=0) {
-      assert (lastNumberRows_>=0);
-      if (modelPtr_->rowScale_!=rowScale_.array()) {
-        assert(modelPtr_->columnScale_!=columnScale_.array());
-        delete [] modelPtr_->rowScale_;
-        modelPtr_->rowScale_=NULL;
-        delete [] modelPtr_->columnScale_;
-        modelPtr_->columnScale_=NULL;
-        if (lastNumberRows_==modelPtr_->numberRows()) {
-          // use scaling
-          modelPtr_->rowScale_ = rowScale_.array();
-          modelPtr_->columnScale_ = columnScale_.array();
-        } else {
-          specialOptions_ &= ~131072;
-        }
-      }
-      lastNumberRows_ = -1 -lastNumberRows_;
-    }
-    factorization_ = static_cast<ClpSimplexDual *>(modelPtr_)->setupForStrongBranching(spareArrays_,numberRows,
-                                                                                       numberColumns,true);
-    double * arrayD = reinterpret_cast<double *> (spareArrays_);
-    arrayD[0]=modelPtr_->objectiveValue()* modelPtr_->optimizationDirection();
-    double * saveSolution = arrayD+1;
-    double * saveLower = saveSolution + (numberRows+numberColumns);
-    double * saveUpper = saveLower + (numberRows+numberColumns);
-    double * saveObjective = saveUpper + (numberRows+numberColumns);
-    double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-    double * saveUpperOriginal = saveLowerOriginal + numberColumns;
-    CoinMemcpyN( modelPtr_->columnLower(),numberColumns, saveLowerOriginal);
-    CoinMemcpyN( modelPtr_->columnUpper(),numberColumns, saveUpperOriginal);
+    assert(factorization_ == NULL);
+    if ((specialOptions_ & 131072) != 0) {
+      assert(lastNumberRows_ >= 0);
+      if (modelPtr_->rowScale_ != rowScale_.array()) {
+        assert(modelPtr_->columnScale_ != columnScale_.array());
+        delete[] modelPtr_->rowScale_;
+        modelPtr_->rowScale_ = NULL;
+        delete[] modelPtr_->columnScale_;
+        modelPtr_->columnScale_ = NULL;
+        if (lastNumberRows_ == modelPtr_->numberRows()) {
+          // use scaling
+          modelPtr_->rowScale_ = rowScale_.array();
+          modelPtr_->columnScale_ = columnScale_.array();
+        } else {
+          specialOptions_ &= ~131072;
+        }
+      }
+      lastNumberRows_ = -1 - lastNumberRows_;
+    }
+    factorization_ = static_cast< ClpSimplexDual * >(modelPtr_)->setupForStrongBranching(spareArrays_, numberRows,
+      numberColumns, true);
+    double *arrayD = reinterpret_cast< double * >(spareArrays_);
+    arrayD[0] = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
+    double *saveSolution = arrayD + 1;
+    double *saveLower = saveSolution + (numberRows + numberColumns);
+    double *saveUpper = saveLower + (numberRows + numberColumns);
+    double *saveObjective = saveUpper + (numberRows + numberColumns);
+    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
+    CoinMemcpyN(modelPtr_->columnLower(), numberColumns, saveLowerOriginal);
+    CoinMemcpyN(modelPtr_->columnUpper(), numberColumns, saveUpperOriginal);
 #if 0
     if (whichRange_&&whichRange_[0]) {
@@ -1811 +1794 @@
       columnActivity_=downRange;
     }
-#endif 
+#endif
     if (savedObjective) {
       // fix up
-      modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
+      modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
       //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-      modelPtr_->objective_=savedObjective;
+      modelPtr_->objective_ = savedObjective;
       if (!modelPtr_->problemStatus_) {
-        CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-        CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-        if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-          CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
-        modelPtr_->computeObjectiveValue();
+        CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+        CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+        if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+          CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
+        modelPtr_->computeObjectiveValue();
       }
     }
@@ -1828 +1811 @@
   }
 #endif
-  if ((specialOptions_&8192)==0&&false) { // ||(specialOptions_&65536)!=0) {
+  if ((specialOptions_ & 8192) == 0 && false) { // ||(specialOptions_&65536)!=0) {
     delete ws_;
-    ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
+    ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
     int numberRows = modelPtr_->numberRows();
-    rowActivity_= new double[numberRows];
-    CoinMemcpyN(modelPtr_->primalRowSolution(),numberRows,rowActivity_);
+    rowActivity_ = new double[numberRows];
+    CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
     int numberColumns = modelPtr_->numberColumns();
-    columnActivity_= new double[numberColumns];
-    CoinMemcpyN(modelPtr_->primalColumnSolution(),numberColumns,columnActivity_);
+    columnActivity_ = new double[numberColumns];
+    CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
   } else {
 #if 0
@@ -1853 +1836 @@
     int numberRows = modelPtr_->numberRows();
     // Get space for crunch and strong branching (too much)
-    int size = static_cast<int>((1+4*(numberRows+numberColumns))*sizeof(double));
+    int size = static_cast< int >((1 + 4 * (numberRows + numberColumns)) * sizeof(double));
     // and for save of original column bounds
-    size += static_cast<int>(2*numberColumns*sizeof(double));
-    size += static_cast<int>((1+4*numberRows+2*numberColumns)*sizeof(int));
-    size += numberRows+numberColumns;
+    size += static_cast< int >(2 * numberColumns * sizeof(double));
+    size += static_cast< int >((1 + 4 * numberRows + 2 * numberColumns) * sizeof(int));
+    size += numberRows + numberColumns;
 #ifdef KEEP_SMALL
-    if(smallModel_&&(modelPtr_->whatsChanged_&0x30000)!=0x30000) {
+    if (smallModel_ && (modelPtr_->whatsChanged_ & 0x30000) != 0x30000) {
       //printf("Bounds changed ? %x\n",modelPtr_->whatsChanged_);
       delete smallModel_;
-      smallModel_=NULL;
+      smallModel_ = NULL;
     }
     if (!smallModel_) {
-      delete [] spareArrays_;
+      delete[] spareArrays_;
       spareArrays_ = NULL;
     }
 #endif
-    if (spareArrays_==NULL) {
+    if (spareArrays_ == NULL) {
       //if (smallModel_)
       //printf("small model %x\n",smallModel_);
       delete smallModel_;
-      smallModel_=NULL;
+      smallModel_ = NULL;
       spareArrays_ = new char[size];
       //memset(spareArrays_,0x20,size);
     } else {
-      double * arrayD = reinterpret_cast<double *> (spareArrays_);
-      double * saveSolution = arrayD+1;
-      double * saveLower = saveSolution + (numberRows+numberColumns);
-      double * saveUpper = saveLower + (numberRows+numberColumns);
-      double * saveObjective = saveUpper + (numberRows+numberColumns);
-      double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-      double * saveUpperOriginal = saveLowerOriginal + numberColumns;
-      double * lowerOriginal = modelPtr_->columnLower();
-      double * upperOriginal = modelPtr_->columnUpper();
+      double *arrayD = reinterpret_cast< double * >(spareArrays_);
+      double *saveSolution = arrayD + 1;
+      double *saveLower = saveSolution + (numberRows + numberColumns);
+      double *saveUpper = saveLower + (numberRows + numberColumns);
+      double *saveObjective = saveUpper + (numberRows + numberColumns);
+      double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+      double *saveUpperOriginal = saveLowerOriginal + numberColumns;
+      double *lowerOriginal = modelPtr_->columnLower();
+      double *upperOriginal = modelPtr_->columnUpper();
       arrayD = saveUpperOriginal + numberColumns;
-      int * savePivot = reinterpret_cast<int *> (arrayD);
-      int * whichRow = savePivot+numberRows;
-      int * whichColumn = whichRow + 3*numberRows;
-      int nSame=0;
-      int nSub=0;
-      for (int i=0;i<numberColumns;i++) {
-        double lo = lowerOriginal[i];
-        //char * xx = (char *) (saveLowerOriginal+i);
-        //assert (xx[0]!=0x20||xx[1]!=0x20);
-        //xx = (char *) (saveUpperOriginal+i);
-        //assert (xx[0]!=0x20||xx[1]!=0x20);
-        double loOld = saveLowerOriginal[i];
-        //assert (!loOld||fabs(loOld)>1.0e-30);
-        double up = upperOriginal[i];
-        double upOld = saveUpperOriginal[i];
-        if (lo>=loOld&&up<=upOld) {
-          if (lo==loOld&&up==upOld) {
-            nSame++;
-          } else {
-            nSub++;
-            //if (!isInteger(i))
-            //nSub+=10;
-          }
-        }
+      int *savePivot = reinterpret_cast< int * >(arrayD);
+      int *whichRow = savePivot + numberRows;
+      int *whichColumn = whichRow + 3 * numberRows;
+      int nSame = 0;
+      int nSub = 0;
+      for (int i = 0; i < numberColumns; i++) {
+        double lo = lowerOriginal[i];
+        //char * xx = (char *) (saveLowerOriginal+i);
+        //assert (xx[0]!=0x20||xx[1]!=0x20);
+        //xx = (char *) (saveUpperOriginal+i);
+        //assert (xx[0]!=0x20||xx[1]!=0x20);
+        double loOld = saveLowerOriginal[i];
+        //assert (!loOld||fabs(loOld)>1.0e-30);
+        double up = upperOriginal[i];
+        double upOld = saveUpperOriginal[i];
+        if (lo >= loOld && up <= upOld) {
+          if (lo == loOld && up == upOld) {
+            nSame++;
+          } else {
+            nSub++;
+            //if (!isInteger(i))
+            //nSub+=10;
+          }
+        }
       }
       //printf("Mark Hot %d bounds same, %d interior, %d bad\n",
       //     nSame,nSub,numberColumns-nSame-nSub);
-      if (nSame<numberColumns) {
-        if (nSame+nSub<numberColumns) {
-          delete smallModel_;
-          smallModel_=NULL;
-        } else {
-          // we can fix up (but should we if large number fixed?)
-          assert (smallModel_);
-          double * lowerSmall = smallModel_->columnLower();
-          double * upperSmall = smallModel_->columnUpper();
-          int numberColumns2 = smallModel_->numberColumns();
-          for (int i=0;i<numberColumns2;i++) {
-            int iColumn = whichColumn[i];
-            lowerSmall[i]=lowerOriginal[iColumn];
-            upperSmall[i]=upperOriginal[iColumn];
-          }
-        }
-      }
-    }
-    double * arrayD = reinterpret_cast<double *> (spareArrays_);
-    arrayD[0]=modelPtr_->objectiveValue()* modelPtr_->optimizationDirection();
-    double * saveSolution = arrayD+1;
-    double * saveLower = saveSolution + (numberRows+numberColumns);
-    double * saveUpper = saveLower + (numberRows+numberColumns);
-    double * saveObjective = saveUpper + (numberRows+numberColumns);
-    double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-    double * saveUpperOriginal = saveLowerOriginal + numberColumns;
+      if (nSame < numberColumns) {
+        if (nSame + nSub < numberColumns) {
+          delete smallModel_;
+          smallModel_ = NULL;
+        } else {
+          // we can fix up (but should we if large number fixed?)
+          assert(smallModel_);
+          double *lowerSmall = smallModel_->columnLower();
+          double *upperSmall = smallModel_->columnUpper();
+          int numberColumns2 = smallModel_->numberColumns();
+          for (int i = 0; i < numberColumns2; i++) {
+            int iColumn = whichColumn[i];
+            lowerSmall[i] = lowerOriginal[iColumn];
+            upperSmall[i] = upperOriginal[iColumn];
+          }
+        }
+      }
+    }
+    double *arrayD = reinterpret_cast< double * >(spareArrays_);
+    arrayD[0] = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
+    double *saveSolution = arrayD + 1;
+    double *saveLower = saveSolution + (numberRows + numberColumns);
+    double *saveUpper = saveLower + (numberRows + numberColumns);
+    double *saveObjective = saveUpper + (numberRows + numberColumns);
+    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     arrayD = saveUpperOriginal + numberColumns;
-    int * savePivot = reinterpret_cast<int *> (arrayD);
-    int * whichRow = savePivot+numberRows;
-    int * whichColumn = whichRow + 3*numberRows;
-    int * arrayI = whichColumn + 2*numberColumns;
+    int *savePivot = reinterpret_cast< int * >(arrayD);
+    int *whichRow = savePivot + numberRows;
+    int *whichColumn = whichRow + 3 * numberRows;
+    int *arrayI = whichColumn + 2 * numberColumns;
     //unsigned char * saveStatus = (unsigned char *) (arrayI+1);
     // Use dual region
-    double * rhs = modelPtr_->dualRowSolution();
-    int nBound=0;
-    ClpSimplex * small;
+    double *rhs = modelPtr_->dualRowSolution();
+    int nBound = 0;
+    ClpSimplex *small;
 #ifndef KEEP_SMALL
-    assert (!smallModel_);
-    small = static_cast<ClpSimplexOther *> (modelPtr_)->crunch(rhs,whichRow,whichColumn,nBound,true);
-    bool needSolveInSetupHotStart=true;
+    assert(!smallModel_);
+    small = static_cast< ClpSimplexOther * >(modelPtr_)->crunch(rhs, whichRow, whichColumn, nBound, true);
+    bool needSolveInSetupHotStart = true;
 #else
-    bool needSolveInSetupHotStart=true;
+    bool needSolveInSetupHotStart = true;
     if (!smallModel_) {
 #ifndef NDEBUG
-      CoinFillN(whichRow,3*numberRows+2*numberColumns,-1);
-#endif
-      small = static_cast<ClpSimplexOther *> (modelPtr_)->crunch(rhs,whichRow,whichColumn,nBound,true);
+      CoinFillN(whichRow, 3 * numberRows + 2 * numberColumns, -1);
+#endif
+      small = static_cast< ClpSimplexOther * >(modelPtr_)->crunch(rhs, whichRow, whichColumn, nBound, true);
 #ifndef NDEBUG
-      int nCopy = 3*numberRows+2*numberColumns;
-      for (int i=0;i<nCopy;i++)
-        assert (whichRow[i]>=-CoinMax(numberRows,numberColumns)&&whichRow[i]<CoinMax(numberRows,numberColumns));
-#endif
-      smallModel_=small;
+      int nCopy = 3 * numberRows + 2 * numberColumns;
+      for (int i = 0; i < nCopy; i++)
+        assert(whichRow[i] >= -CoinMax(numberRows, numberColumns) && whichRow[i] < CoinMax(numberRows, numberColumns));
+#endif
+      smallModel_ = small;
       //int hotIts = small->intParam_[ClpMaxNumIterationHotStart];
       //if (5*small->factorization_->maximumPivots()>
@@ -1972 +1955 @@
       //small->factorization_->maximumPivots(hotIts+1);
     } else {
-      assert((modelPtr_->whatsChanged_&0x30000)==0x30000);
+      assert((modelPtr_->whatsChanged_ & 0x30000) == 0x30000);
       //delete [] spareArrays_;
       //spareArrays_ = NULL;
-      assert (spareArrays_);
-      int nCopy = 3*numberRows+2*numberColumns;
+      assert(spareArrays_);
+      int nCopy = 3 * numberRows + 2 * numberColumns;
       nBound = whichRow[nCopy];
 #ifndef NDEBUG
-      for (int i=0;i<nCopy;i++)
-        assert (whichRow[i]>=-CoinMax(numberRows,numberColumns)&&whichRow[i]<CoinMax(numberRows,numberColumns));
-#endif
-      needSolveInSetupHotStart=false;
+      for (int i = 0; i < nCopy; i++)
+        assert(whichRow[i] >= -CoinMax(numberRows, numberColumns) && whichRow[i] < CoinMax(numberRows, numberColumns));
+#endif
+      needSolveInSetupHotStart = false;
       small = smallModel_;
     }
@@ -1990 +1973 @@
       small->specialOptions_ &= ~65536;
     }
-    if (small&&(specialOptions_&131072)!=0) {
-      assert (lastNumberRows_>=0);
+    if (small && (specialOptions_ & 131072) != 0) {
+      assert(lastNumberRows_ >= 0);
       int numberRows2 = small->numberRows();
       int numberColumns2 = small->numberColumns();
-      double * rowScale2 = new double [2*numberRows2];
-      const double * rowScale = rowScale_.array();
-      double * inverseScale2 = rowScale2+numberRows2;
-      const double * inverseScale = rowScale+modelPtr_->numberRows_;
+      double *rowScale2 = new double[2 * numberRows2];
+      const double *rowScale = rowScale_.array();
+      double *inverseScale2 = rowScale2 + numberRows2;
+      const double *inverseScale = rowScale + modelPtr_->numberRows_;
       int i;
-      for (i=0;i<numberRows2;i++) {
-        int iRow = whichRow[i];
-        rowScale2[i]=rowScale[iRow];
-        inverseScale2[i]=inverseScale[iRow];
+      for (i = 0; i < numberRows2; i++) {
+        int iRow = whichRow[i];
+        rowScale2[i] = rowScale[iRow];
+        inverseScale2[i] = inverseScale[iRow];
       }
       small->setRowScale(rowScale2);
-      double * columnScale2 = new double [2*numberColumns2];
-      const double * columnScale = columnScale_.array();
-      inverseScale2 = columnScale2+numberColumns2;
-      inverseScale = columnScale+modelPtr_->numberColumns_;
-      for (i=0;i<numberColumns2;i++) {
-        int iColumn = whichColumn[i];
-        columnScale2[i]=columnScale[iColumn];
-        inverseScale2[i]=inverseScale[iColumn];
+      double *columnScale2 = new double[2 * numberColumns2];
+      const double *columnScale = columnScale_.array();
+      inverseScale2 = columnScale2 + numberColumns2;
+      inverseScale = columnScale + modelPtr_->numberColumns_;
+      for (i = 0; i < numberColumns2; i++) {
+        int iColumn = whichColumn[i];
+        columnScale2[i] = columnScale[iColumn];
+        inverseScale2[i] = inverseScale[iColumn];
       }
       small->setColumnScale(columnScale2);
@@ -2018 +2001 @@
     if (!small) {
       // should never be infeasible .... but
-      delete [] spareArrays_;
-      spareArrays_=NULL;
+      delete[] spareArrays_;
+      spareArrays_ = NULL;
       delete ws_;
-      ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
+      ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
       int numberRows = modelPtr_->numberRows();
-      rowActivity_= new double[numberRows];
-      CoinMemcpyN(modelPtr_->primalRowSolution(),numberRows,rowActivity_);
+      rowActivity_ = new double[numberRows];
+      CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
       int numberColumns = modelPtr_->numberColumns();
-      columnActivity_= new double[numberColumns];
-      CoinMemcpyN(modelPtr_->primalColumnSolution(),numberColumns,columnActivity_);
+      columnActivity_ = new double[numberColumns];
+      CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
       modelPtr_->setProblemStatus(1);
       if (savedObjective) {
-        // fix up
-        modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
-        //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-        modelPtr_->objective_=savedObjective;
+        // fix up
+        modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
+        //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
+        modelPtr_->objective_ = savedObjective;
       }
       return;
@@ -2039 +2022 @@
     int clpOptions = modelPtr_->specialOptions();
     clpOptions &= ~65536;
-    if((specialOptions_&1)==0) {
-      small->setSpecialOptions(clpOptions|(64|1024));
+    if ((specialOptions_ & 1) == 0) {
+      small->setSpecialOptions(clpOptions | (64 | 1024));
     } else {
-      if((specialOptions_&4)==0) 
-        small->setSpecialOptions(clpOptions|(64|128|512|1024|4096));
+      if ((specialOptions_ & 4) == 0)
+        small->setSpecialOptions(clpOptions | (64 | 128 | 512 | 1024 | 4096));
       else
-        small->setSpecialOptions(clpOptions|(64|128|512|1024|2048|4096));
-    }
-    arrayI[0]=nBound;
-    assert (smallModel_==NULL||small==smallModel_);
-    if ((specialOptions_&256)!=0||1) {
+        small->setSpecialOptions(clpOptions | (64 | 128 | 512 | 1024 | 2048 | 4096));
+    }
+    arrayI[0] = nBound;
+    assert(smallModel_ == NULL || small == smallModel_);
+    if ((specialOptions_ & 256) != 0 || 1) {
       // only need to do this on second pass in CbcNode
-      if (modelPtr_->logLevel()<2) small->setLogLevel(0);
+      if (modelPtr_->logLevel() < 2)
+        small->setLogLevel(0);
       small->specialOptions_ |= 262144;
       small->moreSpecialOptions_ = modelPtr_->moreSpecialOptions_;
@@ -2058 +2042 @@
       small->dual();
 #else
-      assert (factorization_==NULL);
+      assert(factorization_ == NULL);
       //needSolveInSetupHotStart=true;
-      ClpFactorization * factorization = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,
-                       numberRows,numberColumns,
-                                                                                                       needSolveInSetupHotStart);
-#endif
-      if (small->numberIterations()>0&&small->logLevel()>2)
-        printf("**** iterated small %d\n",small->numberIterations());
+      ClpFactorization *factorization = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_,
+        numberRows, numberColumns,
+        needSolveInSetupHotStart);
+#endif
+      if (small->numberIterations() > 0 && small->logLevel() > 2)
+        printf("**** iterated small %d\n", small->numberIterations());
       //small->setLogLevel(0);
       // Could be infeasible if forced one way (and other way stopped on iterations)
@@ -2071 +2055 @@
       if (small->status()) {
 #ifndef KEEP_SMALL
-        if (small!=modelPtr_)
-          delete small;
-        //delete smallModel_;
-        //smallModel_=NULL;
-        assert (!smallModel_);
+        if (small != modelPtr_)
+          delete small;
+        //delete smallModel_;
+        //smallModel_=NULL;
+        assert(!smallModel_);
 #else
-        assert (small==smallModel_);
-        if (smallModel_!=modelPtr_) {
-          delete smallModel_;
-        }
-        smallModel_=NULL;
-#endif
-        delete [] spareArrays_;
-        spareArrays_=NULL;
-        delete ws_;
-        ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
-        int numberRows = modelPtr_->numberRows();
-        rowActivity_= new double[numberRows];
- CoinMemcpyN(modelPtr_->primalRowSolution(),    numberRows,rowActivity_);
-        int numberColumns = modelPtr_->numberColumns();
-        columnActivity_= new double[numberColumns];
- CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns,columnActivity_);
-        modelPtr_->setProblemStatus(1);
-        if (savedObjective) {
-          // fix up
-          modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
-          //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-          modelPtr_->objective_=savedObjective;
-        }
-        return;
+        assert(small == smallModel_);
+        if (smallModel_ != modelPtr_) {
+          delete smallModel_;
+        }
+        smallModel_ = NULL;
+#endif
+        delete[] spareArrays_;
+        spareArrays_ = NULL;
+        delete ws_;
+        ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
+        int numberRows = modelPtr_->numberRows();
+        rowActivity_ = new double[numberRows];
+        CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
+        int numberColumns = modelPtr_->numberColumns();
+        columnActivity_ = new double[numberColumns];
+        CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
+        modelPtr_->setProblemStatus(1);
+        if (savedObjective) {
+          // fix up
+          modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
+          //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
+          modelPtr_->objective_ = savedObjective;
+        }
+        return;
       } else {
-        // update model
-        static_cast<ClpSimplexOther *> (modelPtr_)->afterCrunch(*small,whichRow,whichColumn,nBound);
-      } 
+        // update model
+        static_cast< ClpSimplexOther * >(modelPtr_)->afterCrunch(*small, whichRow, whichColumn, nBound);
+      }
 #ifndef SETUP_HOT
-      assert (factorization_==NULL);
-      factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,
-                             numberColumns,false);
+      assert(factorization_ == NULL);
+      factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows,
+        numberColumns, false);
 #else
-      assert (factorization!=NULL || small->problemStatus_ );
+      assert(factorization != NULL || small->problemStatus_);
       factorization_ = factorization;
       if (factorization_ == NULL)
-        factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,numberColumns,false);
+        factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows, numberColumns, false);
 #endif
     } else {
-      assert (factorization_==NULL);
-      factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,
-                                                                                     numberColumns,false);
-    }
-    smallModel_=small;
-    if (modelPtr_->logLevel()<2) smallModel_->setLogLevel(0);
+      assert(factorization_ == NULL);
+      factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows,
+        numberColumns, false);
+    }
+    smallModel_ = small;
+    if (modelPtr_->logLevel() < 2)
+      smallModel_->setLogLevel(0);
     // Setup for strong branching
     int numberColumns2 = smallModel_->numberColumns();
-    CoinMemcpyN( modelPtr_->columnLower(),numberColumns, saveLowerOriginal);
-    CoinMemcpyN( modelPtr_->columnUpper(),numberColumns, saveUpperOriginal);
-    const double * smallLower = smallModel_->columnLower();
-    const double * smallUpper = smallModel_->columnUpper();
+    CoinMemcpyN(modelPtr_->columnLower(), numberColumns, saveLowerOriginal);
+    CoinMemcpyN(modelPtr_->columnUpper(), numberColumns, saveUpperOriginal);
+    const double *smallLower = smallModel_->columnLower();
+    const double *smallUpper = smallModel_->columnUpper();
     // But modify if bounds changed in small
-    for (int i=0;i<numberColumns2;i++) {
+    for (int i = 0; i < numberColumns2; i++) {
       int iColumn = whichColumn[i];
       saveLowerOriginal[iColumn] = CoinMax(saveLowerOriginal[iColumn],
-                                           smallLower[i]);
+        smallLower[i]);
       saveUpperOriginal[iColumn] = CoinMin(saveUpperOriginal[iColumn],
-                                           smallUpper[i]);
-    }
-    if (whichRange_&&whichRange_[0]) {
+        smallUpper[i]);
+    }
+    if (whichRange_ && whichRange_[0]) {
       // get ranging information
       int numberToDo = whichRange_[0];
-      int * which = new int [numberToDo];
+      int *which = new int[numberToDo];
       // Convert column numbers
-      int * backColumn = whichColumn+numberColumns;
-      for (int i=0;i<numberToDo;i++) {
-        int iColumn = whichRange_[i+1];
-        which[i]=backColumn[iColumn];
-      }
-      double * downRange=new double [numberToDo];
-      double * upRange=new double [numberToDo];
-      int * whichDown = new int [numberToDo];
-      int * whichUp = new int [numberToDo];
+      int *backColumn = whichColumn + numberColumns;
+      for (int i = 0; i < numberToDo; i++) {
+        int iColumn = whichRange_[i + 1];
+        which[i] = backColumn[iColumn];
+      }
+      double *downRange = new double[numberToDo];
+      double *upRange = new double[numberToDo];
+      int *whichDown = new int[numberToDo];
+      int *whichUp = new int[numberToDo];
       smallModel_->setFactorization(*factorization_);
-      smallModel_->gutsOfSolution(NULL,NULL,false);
+      smallModel_->gutsOfSolution(NULL, NULL, false);
       // Tell code we can increase costs in some cases
       smallModel_->setCurrentDualTolerance(0.0);
-      static_cast<ClpSimplexOther *> (smallModel_)->dualRanging(numberToDo,which,
-                         upRange, whichUp, downRange, whichDown);
-      delete [] whichDown;
-      delete [] whichUp;
-      delete [] which;
-      rowActivity_=upRange;
-      columnActivity_=downRange;
-    }
-  }
-    if (savedObjective) {
-      // fix up
-      modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
-      //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-      modelPtr_->objective_=savedObjective;
-      if (!modelPtr_->problemStatus_) {
-        CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-        CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-        if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-          CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
-        modelPtr_->computeObjectiveValue();
-      }
-    }
+      static_cast< ClpSimplexOther * >(smallModel_)->dualRanging(numberToDo, which, upRange, whichUp, downRange, whichDown);
+      delete[] whichDown;
+      delete[] whichUp;
+      delete[] which;
+      rowActivity_ = upRange;
+      columnActivity_ = downRange;
+    }
+  }
+  if (savedObjective) {
+    // fix up
+    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
+    //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
+    modelPtr_->objective_ = savedObjective;
+    if (!modelPtr_->problemStatus_) {
+      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
+      modelPtr_->computeObjectiveValue();
+    }
+  }
 }
 
@@ -2182 +2166 @@
 #ifdef KEEP_SMALL
   if (!spareArrays_) {
-    assert (!smallModel_);
-    assert (modelPtr_->problemStatus_==1);
+    assert(!smallModel_);
+    assert(modelPtr_->problemStatus_ == 1);
     return;
   }
 #endif
-  ClpObjective * savedObjective=NULL;
-  double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
+  ClpObjective *savedObjective = NULL;
+  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
   if (saveData_.perturbation_) {
     // Set fake
-    savedObjective=modelPtr_->objective_;
-    modelPtr_->objective_=fakeObjective_;
-    modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
+    savedObjective = modelPtr_->objective_;
+    modelPtr_->objective_ = fakeObjective_;
+    modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
   }
   int numberRows = modelPtr_->numberRows();
   int numberColumns = modelPtr_->numberColumns();
-  modelPtr_->getIntParam(ClpMaxNumIteration,itlimOrig_);
+  modelPtr_->getIntParam(ClpMaxNumIteration, itlimOrig_);
   int itlim;
   modelPtr_->getIntParam(ClpMaxNumIterationHotStart, itlim);
   // Is there an extra copy of scaled bounds
-  int extraCopy = (modelPtr_->maximumRows_>0) ? modelPtr_->maximumRows_+modelPtr_->maximumColumns_ : 0; 
+  int extraCopy = (modelPtr_->maximumRows_ > 0) ? modelPtr_->maximumRows_ + modelPtr_->maximumColumns_ : 0;
 #ifdef CLEAN_HOT_START
-  if ((specialOptions_&65536)!=0) {
-    double * arrayD = reinterpret_cast<double *> (spareArrays_);
+  if ((specialOptions_ & 65536) != 0) {
+    double *arrayD = reinterpret_cast< double * >(spareArrays_);
     double saveObjectiveValue = arrayD[0];
-    double * saveSolution = arrayD+1;
-    int number = numberRows+numberColumns;
-    CoinMemcpyN(saveSolution,number,modelPtr_->solutionRegion());
-    double * saveLower = saveSolution + (numberRows+numberColumns);
-    CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion());
-    double * saveUpper = saveLower + (numberRows+numberColumns);
-    CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion());
-    double * saveObjective = saveUpper + (numberRows+numberColumns);
-    CoinMemcpyN(saveObjective,number,modelPtr_->costRegion());
-    double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-    double * saveUpperOriginal = saveLowerOriginal + numberColumns;
+    double *saveSolution = arrayD + 1;
+    int number = numberRows + numberColumns;
+    CoinMemcpyN(saveSolution, number, modelPtr_->solutionRegion());
+    double *saveLower = saveSolution + (numberRows + numberColumns);
+    CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion());
+    double *saveUpper = saveLower + (numberRows + numberColumns);
+    CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion());
+    double *saveObjective = saveUpper + (numberRows + numberColumns);
+    CoinMemcpyN(saveObjective, number, modelPtr_->costRegion());
+    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     arrayD = saveUpperOriginal + numberColumns;
-    int * savePivot = reinterpret_cast<int *> (arrayD);
-    CoinMemcpyN(savePivot,numberRows,modelPtr_->pivotVariable());
-    int * whichRow = savePivot+numberRows;
-    int * whichColumn = whichRow + 3*numberRows;
-    int * arrayI = whichColumn + 2*numberColumns;
-    unsigned char * saveStatus = reinterpret_cast<unsigned char *> (arrayI+1);
-    CoinMemcpyN(saveStatus,number,modelPtr_->statusArray());
+    int *savePivot = reinterpret_cast< int * >(arrayD);
+    CoinMemcpyN(savePivot, numberRows, modelPtr_->pivotVariable());
+    int *whichRow = savePivot + numberRows;
+    int *whichColumn = whichRow + 3 * numberRows;
+    int *arrayI = whichColumn + 2 * numberColumns;
+    unsigned char *saveStatus = reinterpret_cast< unsigned char * >(arrayI + 1);
+    CoinMemcpyN(saveStatus, number, modelPtr_->statusArray());
     modelPtr_->setFactorization(*factorization_);
-    double * columnLower = modelPtr_->columnLower();
-    double * columnUpper = modelPtr_->columnUpper();
+    double *columnLower = modelPtr_->columnLower();
+    double *columnUpper = modelPtr_->columnUpper();
     // make sure whatsChanged_ has 1 set
     modelPtr_->setWhatsChanged(511);
-    double * lowerInternal = modelPtr_->lowerRegion();
-    double * upperInternal = modelPtr_->upperRegion();
+    double *lowerInternal = modelPtr_->lowerRegion();
+    double *upperInternal = modelPtr_->upperRegion();
     double rhsScale = modelPtr_->rhsScale();
-    const double * columnScale = NULL;
-    if (modelPtr_->scalingFlag()>0) 
-      columnScale = modelPtr_->columnScale() ;
+    const double *columnScale = NULL;
+    if (modelPtr_->scalingFlag() > 0)
+      columnScale = modelPtr_->columnScale();
     // and do bounds in case dual needs them
     int iColumn;
-    for (iColumn=0;iColumn<numberColumns;iColumn++) {
-      if (columnLower[iColumn]>saveLowerOriginal[iColumn]) {
-        double value = columnLower[iColumn];
-        value *= rhsScale;
-        if (columnScale)
-          value /= columnScale[iColumn];
-        lowerInternal[iColumn]=value;
-        if (extraCopy)
-          lowerInternal[iColumn+extraCopy]=value;
-      }
-      if (columnUpper[iColumn]<saveUpperOriginal[iColumn]) {
-        double value = columnUpper[iColumn];
-        value *= rhsScale;
-        if (columnScale)
-          value /= columnScale[iColumn];
-        upperInternal[iColumn]=value;
-        if (extraCopy)
-          upperInternal[iColumn+extraCopy]=value;
+    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+      if (columnLower[iColumn] > saveLowerOriginal[iColumn]) {
+        double value = columnLower[iColumn];
+        value *= rhsScale;
+        if (columnScale)
+          value /= columnScale[iColumn];
+        lowerInternal[iColumn] = value;
+        if (extraCopy)
+          lowerInternal[iColumn + extraCopy] = value;
+      }
+      if (columnUpper[iColumn] < saveUpperOriginal[iColumn]) {
+        double value = columnUpper[iColumn];
+        value *= rhsScale;
+        if (columnScale)
+          value /= columnScale[iColumn];
+        upperInternal[iColumn] = value;
+        if (extraCopy)
+          upperInternal[iColumn + extraCopy] = value;
       }
     }
     // Start of fast iterations
-    bool alwaysFinish= ((specialOptions_&32)==0) ? true : false;
+    bool alwaysFinish = ((specialOptions_ & 32) == 0) ? true : false;
     //modelPtr_->setLogLevel(1);
-    modelPtr_->setIntParam(ClpMaxNumIteration,itlim);
-    int saveNumberFake = (static_cast<ClpSimplexDual *>(modelPtr_))->numberFake_;
-    int status = (static_cast<ClpSimplexDual *>(modelPtr_))->fastDual(alwaysFinish);
-    (static_cast<ClpSimplexDual *>(modelPtr_))->numberFake_ = saveNumberFake;
-    
+    modelPtr_->setIntParam(ClpMaxNumIteration, itlim);
+    int saveNumberFake = (static_cast< ClpSimplexDual * >(modelPtr_))->numberFake_;
+    int status = (static_cast< ClpSimplexDual * >(modelPtr_))->fastDual(alwaysFinish);
+    (static_cast< ClpSimplexDual * >(modelPtr_))->numberFake_ = saveNumberFake;
+
     int problemStatus = modelPtr_->problemStatus();
-    double objectiveValue =modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
-    CoinAssert (modelPtr_->problemStatus()||modelPtr_->objectiveValue()<1.0e50);
+    double objectiveValue = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
+    CoinAssert(modelPtr_->problemStatus() || modelPtr_->objectiveValue() < 1.0e50);
     // make sure plausible
-    double obj = CoinMax(objectiveValue,saveObjectiveValue);
-    if (problemStatus==10||problemStatus<0) {
+    double obj = CoinMax(objectiveValue, saveObjectiveValue);
+    if (problemStatus == 10 || problemStatus < 0) {
       // was trying to clean up or something odd
-      if (problemStatus==10) {
-        obj = saveObjectiveValue;
-        lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
-      }
-      status=1;
+      if (problemStatus == 10) {
+        obj = saveObjectiveValue;
+        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
+      }
+      status = 1;
     }
     if (status) {
       // not finished - might be optimal
       modelPtr_->checkPrimalSolution(modelPtr_->solutionRegion(0),
-                                     modelPtr_->solutionRegion(1));
+        modelPtr_->solutionRegion(1));
       //modelPtr_->gutsOfSolution(NULL,NULL,0);
       //if (problemStatus==3)
       //modelPtr_->computeObjectiveValue();
-      objectiveValue =modelPtr_->objectiveValue() *
-        modelPtr_->optimizationDirection();
-      obj = CoinMax(objectiveValue,saveObjectiveValue);
-      if (!modelPtr_->numberDualInfeasibilities()) { 
-        double limit = 0.0;
-        modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
-        if (modelPtr_->secondaryStatus()==1&&!problemStatus&&obj<limit) {
-          obj=limit;
-          problemStatus=3;
-        }
-        if (!modelPtr_->numberPrimalInfeasibilities()&&obj<limit) { 
-          problemStatus=0;
-        } else if (problemStatus==10) {
-          problemStatus=3;
-          obj = saveObjectiveValue;
-        } else if (!modelPtr_->numberPrimalInfeasibilities()) {
-          problemStatus=1; // infeasible
-        } 
+      objectiveValue = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
+      obj = CoinMax(objectiveValue, saveObjectiveValue);
+      if (!modelPtr_->numberDualInfeasibilities()) {
+        double limit = 0.0;
+        modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
+        if (modelPtr_->secondaryStatus() == 1 && !problemStatus && obj < limit) {
+          obj = limit;
+          problemStatus = 3;
+        }
+        if (!modelPtr_->numberPrimalInfeasibilities() && obj < limit) {
+          problemStatus = 0;
+        } else if (problemStatus == 10) {
+          problemStatus = 3;
+          obj = saveObjectiveValue;
+        } else if (!modelPtr_->numberPrimalInfeasibilities()) {
+          problemStatus = 1; // infeasible
+        }
       } else {
-        // can't say much
-        //if (problemStatus==3)
-        //modelPtr_->computeObjectiveValue();
-        lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
-        obj = saveObjectiveValue;
-        problemStatus=3;
+        // can't say much
+        //if (problemStatus==3)
+        //modelPtr_->computeObjectiveValue();
+        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
+        obj = saveObjectiveValue;
+        problemStatus = 3;
       }
     } else if (!problemStatus) {
-      if (modelPtr_->isDualObjectiveLimitReached()) 
-        problemStatus=1; // infeasible
-    }
-    if (status&&!problemStatus) {
-      problemStatus=3; // can't be sure
-      lastAlgorithm_=1;
-    }
-    if (problemStatus<0)
-      problemStatus=3;
+      if (modelPtr_->isDualObjectiveLimitReached())
+        problemStatus = 1; // infeasible
+    }
+    if (status && !problemStatus) {
+      problemStatus = 3; // can't be sure
+      lastAlgorithm_ = 1;
+    }
+    if (problemStatus < 0)
+      problemStatus = 3;
     modelPtr_->setProblemStatus(problemStatus);
-    modelPtr_->setObjectiveValue(obj*modelPtr_->optimizationDirection());
-    double * solution = modelPtr_->primalColumnSolution();
-    const double * solution2 = modelPtr_->solutionRegion();
+    modelPtr_->setObjectiveValue(obj * modelPtr_->optimizationDirection());
+    double *solution = modelPtr_->primalColumnSolution();
+    const double *solution2 = modelPtr_->solutionRegion();
     // could just do changed bounds - also try double size scale so can use * not /
     if (!columnScale) {
-      for (iColumn=0;iColumn<numberColumns;iColumn++) {
-        solution[iColumn]= solution2[iColumn];
+      for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+        solution[iColumn] = solution2[iColumn];
       }
     } else {
-      for (iColumn=0;iColumn<numberColumns;iColumn++) {
-        solution[iColumn]= solution2[iColumn]*columnScale[iColumn];
-      }
-    }
-    CoinMemcpyN(saveLowerOriginal,numberColumns,columnLower);
-    CoinMemcpyN(saveUpperOriginal,numberColumns,columnUpper);
+      for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+        solution[iColumn] = solution2[iColumn] * columnScale[iColumn];
+      }
+    }
+    CoinMemcpyN(saveLowerOriginal, numberColumns, columnLower);
+    CoinMemcpyN(saveUpperOriginal, numberColumns, columnUpper);
 #if 0
     // could combine with loop above
@@ -2356 +2339 @@
 #endif
     // and back bounds
-    CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion());
-    CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion());
+    CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion());
+    CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion());
     if (extraCopy) {
-      CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion()+extraCopy);
-      CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion()+extraCopy);
-    }
-    modelPtr_->setIntParam(ClpMaxNumIteration,itlimOrig_);
+      CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion() + extraCopy);
+      CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion() + extraCopy);
+    }
+    modelPtr_->setIntParam(ClpMaxNumIteration, itlimOrig_);
     if (savedObjective) {
       // fix up
-      modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
+      modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
       //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-      modelPtr_->objective_=savedObjective;
+      modelPtr_->objective_ = savedObjective;
       if (!modelPtr_->problemStatus_) {
-        CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-        CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-        if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-          CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
-        modelPtr_->computeObjectiveValue();
+        CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+        CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+        if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+          CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
+        modelPtr_->computeObjectiveValue();
       }
     }
@@ -2379 +2362 @@
   }
 #endif
-  if (smallModel_==NULL) {
+  if (smallModel_ == NULL) {
     setWarmStart(ws_);
-    CoinMemcpyN(           rowActivity_,numberRows,modelPtr_->primalRowSolution());
-    CoinMemcpyN(columnActivity_,numberColumns,modelPtr_->primalColumnSolution());
-    modelPtr_->setIntParam(ClpMaxNumIteration,CoinMin(itlim,9999));
+    CoinMemcpyN(rowActivity_, numberRows, modelPtr_->primalRowSolution());
+    CoinMemcpyN(columnActivity_, numberColumns, modelPtr_->primalColumnSolution());
+    modelPtr_->setIntParam(ClpMaxNumIteration, CoinMin(itlim, 9999));
     resolve();
   } else {
-    assert (spareArrays_);
-    double * arrayD = reinterpret_cast<double *> (spareArrays_);
+    assert(spareArrays_);
+    double *arrayD = reinterpret_cast< double * >(spareArrays_);
     double saveObjectiveValue = arrayD[0];
-    double * saveSolution = arrayD+1;
+    double *saveSolution = arrayD + 1;
     // double check arrays exist (? for nonlinear)
     //if (!smallModel_->solutionRegion())
@@ -2395 +2378 @@
     int numberRows2 = smallModel_->numberRows();
     int numberColumns2 = smallModel_->numberColumns();
-    int number = numberRows2+numberColumns2;
-    CoinMemcpyN(saveSolution,number,smallModel_->solutionRegion());
-    double * saveLower = saveSolution + (numberRows+numberColumns);
-    CoinMemcpyN(saveLower,number,smallModel_->lowerRegion());
-    double * saveUpper = saveLower + (numberRows+numberColumns);
-    CoinMemcpyN(saveUpper,number,smallModel_->upperRegion());
-    double * saveObjective = saveUpper + (numberRows+numberColumns);
-    CoinMemcpyN(saveObjective,number,smallModel_->costRegion());
-    double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-    double * saveUpperOriginal = saveLowerOriginal + numberColumns;
+    int number = numberRows2 + numberColumns2;
+    CoinMemcpyN(saveSolution, number, smallModel_->solutionRegion());
+    double *saveLower = saveSolution + (numberRows + numberColumns);
+    CoinMemcpyN(saveLower, number, smallModel_->lowerRegion());
+    double *saveUpper = saveLower + (numberRows + numberColumns);
+    CoinMemcpyN(saveUpper, number, smallModel_->upperRegion());
+    double *saveObjective = saveUpper + (numberRows + numberColumns);
+    CoinMemcpyN(saveObjective, number, smallModel_->costRegion());
+    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     arrayD = saveUpperOriginal + numberColumns;
-    int * savePivot = reinterpret_cast<int *> (arrayD);
-    CoinMemcpyN(savePivot,numberRows2,smallModel_->pivotVariable());
-    int * whichRow = savePivot+numberRows;
-    int * whichColumn = whichRow + 3*numberRows;
-    int * arrayI = whichColumn + 2*numberColumns;
-    unsigned char * saveStatus = reinterpret_cast<unsigned char *> (arrayI+1);
-    CoinMemcpyN(saveStatus,number,smallModel_->statusArray());
+    int *savePivot = reinterpret_cast< int * >(arrayD);
+    CoinMemcpyN(savePivot, numberRows2, smallModel_->pivotVariable());
+    int *whichRow = savePivot + numberRows;
+    int *whichColumn = whichRow + 3 * numberRows;
+    int *arrayI = whichColumn + 2 * numberColumns;
+    unsigned char *saveStatus = reinterpret_cast< unsigned char * >(arrayI + 1);
+    CoinMemcpyN(saveStatus, number, smallModel_->statusArray());
     /* If factorization_ NULL then infeasible
        not really sure how could have slipped through.
        But this can't make situation worse */
-    if (factorization_) 
+    if (factorization_)
       smallModel_->setFactorization(*factorization_);
     //int * backColumn = whichColumn+numberColumns;
-    const double * lowerBig = modelPtr_->columnLower();
-    const double * upperBig = modelPtr_->columnUpper();
+    const double *lowerBig = modelPtr_->columnLower();
+    const double *upperBig = modelPtr_->columnUpper();
     // make sure whatsChanged_ has 1 set
     smallModel_->setWhatsChanged(511);
-    double * lowerSmall = smallModel_->lowerRegion();
-    double * upperSmall = smallModel_->upperRegion();
-    double * solutionSmall = smallModel_->solutionRegion();
-    double * lowerSmallReal = smallModel_->columnLower();
-    double * upperSmallReal = smallModel_->columnUpper();
+    double *lowerSmall = smallModel_->lowerRegion();
+    double *upperSmall = smallModel_->upperRegion();
+    double *solutionSmall = smallModel_->solutionRegion();
+    double *lowerSmallReal = smallModel_->columnLower();
+    double *upperSmallReal = smallModel_->columnUpper();
     int i;
     double rhsScale = smallModel_->rhsScale();
-    const double * columnScale = NULL;
-    const double * rowScale = NULL;
-    if (smallModel_->scalingFlag()>0) {
+    const double *columnScale = NULL;
+    const double *rowScale = NULL;
+    if (smallModel_->scalingFlag() > 0) {
       columnScale = smallModel_->columnScale();
       rowScale = smallModel_->rowScale();
@@ -2438 +2421 @@
     // and do bounds in case dual needs them
     // may be infeasible
-    for (i=0;i<numberColumns2;i++) {
+    for (i = 0; i < numberColumns2; i++) {
       int iColumn = whichColumn[i];
-      if (lowerBig[iColumn]>saveLowerOriginal[iColumn]) {
+      if (lowerBig[iColumn] > saveLowerOriginal[iColumn]) {
         double value = lowerBig[iColumn];
-        lowerSmallReal[i]=value;
+        lowerSmallReal[i] = value;
         value *= rhsScale;
         if (columnScale)
           value /= columnScale[i];
-        lowerSmall[i]=value;
-        if (smallModel_->getColumnStatus(i)==ClpSimplex::atLowerBound)
-          solutionSmall[i]=value;
-      }
-      if (upperBig[iColumn]<saveUpperOriginal[iColumn]) {
+        lowerSmall[i] = value;
+        if (smallModel_->getColumnStatus(i) == ClpSimplex::atLowerBound)
+          solutionSmall[i] = value;
+      }
+      if (upperBig[iColumn] < saveUpperOriginal[iColumn]) {
         double value = upperBig[iColumn];
-        upperSmallReal[i]=value;
+        upperSmallReal[i] = value;
         value *= rhsScale;
         if (columnScale)
           value /= columnScale[i];
-        upperSmall[i]=value;
-        if (smallModel_->getColumnStatus(i)==ClpSimplex::atUpperBound)
-          solutionSmall[i]=value;
-      }
-      if (upperSmall[i]<lowerSmall[i]-1.0e-8)
-        break;
+        upperSmall[i] = value;
+        if (smallModel_->getColumnStatus(i) == ClpSimplex::atUpperBound)
+          solutionSmall[i] = value;
+      }
+      if (upperSmall[i] < lowerSmall[i] - 1.0e-8)
+        break;
     }
     /* If factorization_ NULL then infeasible
        not really sure how could have slipped through.
        But this can't make situation worse */
-    bool infeasible = (i<numberColumns2||!factorization_);
+    bool infeasible = (i < numberColumns2 || !factorization_);
     // Start of fast iterations
-    bool alwaysFinish= ((specialOptions_&32)==0) ? true : false;
+    bool alwaysFinish = ((specialOptions_ & 32) == 0) ? true : false;
     //smallModel_->setLogLevel(1);
-    smallModel_->setIntParam(ClpMaxNumIteration,itlim);
-    int saveNumberFake = (static_cast<ClpSimplexDual *>(smallModel_))->numberFake_;
+    smallModel_->setIntParam(ClpMaxNumIteration, itlim);
+    int saveNumberFake = (static_cast< ClpSimplexDual * >(smallModel_))->numberFake_;
     int status;
     if (!infeasible) {
-      if((modelPtr_->specialOptions()&0x011200000)==0x11200000) {
-        smallModel_->specialOptions_|=2097152;
-        //smallModel_->specialOptions_&=~2097152;
-        delete [] modelPtr_->ray_;
-        delete [] smallModel_->ray_;
-        modelPtr_->ray_=NULL;
-        smallModel_->ray_=NULL;
-      }
-      status = static_cast<ClpSimplexDual *>(smallModel_)->fastDual(alwaysFinish);
-      if((modelPtr_->specialOptions()&0x011200000)==0x11200000&&smallModel_->ray_) {
-        if (smallModel_->sequenceOut_<smallModel_->numberColumns_) 
-            modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
-        else
-            modelPtr_->sequenceOut_ = whichRow[smallModel_->sequenceOut_-smallModel_->numberColumns_]+modelPtr_->numberColumns_;
-        if (smallModel_->rowScale_) {
-          // scale ray
-          double scaleFactor=1.0;
-          if (smallModel_->sequenceOut_<smallModel_->numberColumns_) 
-            scaleFactor = smallModel_->columnScale_[smallModel_->sequenceOut_];
-          for (int i = 0; i < smallModel_->numberRows_; i++) {
-            smallModel_->ray_[i] *= smallModel_->rowScale_[i]*scaleFactor;
-          }
-        }
-      } 
+      if ((modelPtr_->specialOptions() & 0x011200000) == 0x11200000) {
+        smallModel_->specialOptions_ |= 2097152;
+        //smallModel_->specialOptions_&=~2097152;
+        delete[] modelPtr_->ray_;
+        delete[] smallModel_->ray_;
+        modelPtr_->ray_ = NULL;
+        smallModel_->ray_ = NULL;
+      }
+      status = static_cast< ClpSimplexDual * >(smallModel_)->fastDual(alwaysFinish);
+      if ((modelPtr_->specialOptions() & 0x011200000) == 0x11200000 && smallModel_->ray_) {
+        if (smallModel_->sequenceOut_ < smallModel_->numberColumns_)
+          modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
+        else
+          modelPtr_->sequenceOut_ = whichRow[smallModel_->sequenceOut_ - smallModel_->numberColumns_] + modelPtr_->numberColumns_;
+        if (smallModel_->rowScale_) {
+          // scale ray
+          double scaleFactor = 1.0;
+          if (smallModel_->sequenceOut_ < smallModel_->numberColumns_)
+            scaleFactor = smallModel_->columnScale_[smallModel_->sequenceOut_];
+          for (int i = 0; i < smallModel_->numberRows_; i++) {
+            smallModel_->ray_[i] *= smallModel_->rowScale_[i] * scaleFactor;
+          }
+        }
+      }
     } else {
-      status=0;
+      status = 0;
       smallModel_->setProblemStatus(1);
     }
-    (static_cast<ClpSimplexDual *>(smallModel_))->numberFake_ = saveNumberFake;
-    if (smallModel_->numberIterations()==-98) {
+    (static_cast< ClpSimplexDual * >(smallModel_))->numberFake_ = saveNumberFake;
+    if (smallModel_->numberIterations() == -98) {
       printf("rrrrrrrrrrrr\n");
       smallModel_->checkPrimalSolution(smallModel_->solutionRegion(0),
-                                     smallModel_->solutionRegion(1));
+        smallModel_->solutionRegion(1));
       //smallModel_->gutsOfSolution(NULL,NULL,0);
       //if (problemStatus==3)
       //smallModel_->computeObjectiveValue();
-      printf("robj %g\n",smallModel_->objectiveValue() *
-             modelPtr_->optimizationDirection());
+      printf("robj %g\n", smallModel_->objectiveValue() * modelPtr_->optimizationDirection());
       writeMps("rr.mps");
       smallModel_->writeMps("rr_small.mps");
@@ -2520 +2502 @@
       double limit = 0.0;
       modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
-      if (temp.problemStatus()==0&&temp.objectiveValue()<limit) {
-        printf("inf obj %g, true %g - offsets %g %g\n",smallModel_->objectiveValue(),
-               temp.objectiveValue(),
-               smallModel_->objectiveOffset(),temp.objectiveOffset());
+      if (temp.problemStatus() == 0 && temp.objectiveValue() < limit) {
+        printf("inf obj %g, true %g - offsets %g %g\n", smallModel_->objectiveValue(),
+          temp.objectiveValue(),
+          smallModel_->objectiveOffset(), temp.objectiveOffset());
       }
       printf("big\n");
       temp = *modelPtr_;
       temp.dual();
-      if (temp.problemStatus()==0&&temp.objectiveValue()<limit) {
-        printf("inf obj %g, true %g - offsets %g %g\n",smallModel_->objectiveValue(),
-               temp.objectiveValue(),
-               smallModel_->objectiveOffset(),temp.objectiveOffset());
+      if (temp.problemStatus() == 0 && temp.objectiveValue() < limit) {
+        printf("inf obj %g, true %g - offsets %g %g\n", smallModel_->objectiveValue(),
+          temp.objectiveValue(),
+          smallModel_->objectiveOffset(), temp.objectiveOffset());
       }
     }
     int problemStatus = smallModel_->problemStatus();
-    double objectiveValue =smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
-    CoinAssert (smallModel_->problemStatus()||smallModel_->objectiveValue()<1.0e50);
+    double objectiveValue = smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
+    CoinAssert(smallModel_->problemStatus() || smallModel_->objectiveValue() < 1.0e50);
     // make sure plausible
-    double obj = CoinMax(objectiveValue,saveObjectiveValue);
-    if (problemStatus==10||problemStatus<0) {
+    double obj = CoinMax(objectiveValue, saveObjectiveValue);
+    if (problemStatus == 10 || problemStatus < 0) {
       // was trying to clean up or something odd
-      if (problemStatus==10) 
-        lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
-      status=1;
+      if (problemStatus == 10)
+        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
+      status = 1;
     }
     if (status) {
       // not finished - might be optimal
       smallModel_->checkPrimalSolution(smallModel_->solutionRegion(0),
-                                     smallModel_->solutionRegion(1));
+        smallModel_->solutionRegion(1));
       //smallModel_->gutsOfSolution(NULL,NULL,0);
       //if (problemStatus==3)
       //smallModel_->computeObjectiveValue();
-      objectiveValue =smallModel_->objectiveValue() *
-        modelPtr_->optimizationDirection();
-      if (problemStatus!=10)
-        obj = CoinMax(objectiveValue,saveObjectiveValue);
-      if (!smallModel_->numberDualInfeasibilities()) { 
+      objectiveValue = smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
+      if (problemStatus != 10)
+        obj = CoinMax(objectiveValue, saveObjectiveValue);
+      if (!smallModel_->numberDualInfeasibilities()) {
         double limit = 0.0;
         modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
-        if (smallModel_->secondaryStatus()==1&&!problemStatus&&obj<limit) {
+        if (smallModel_->secondaryStatus() == 1 && !problemStatus && obj < limit) {
 #if 0
           // switch off
@@ -2573 +2554 @@
           problemStatus=10;
 #else
-          obj=limit;
-          problemStatus=3;
+          obj = limit;
+          problemStatus = 3;
 #endif
         }
-        if (!smallModel_->numberPrimalInfeasibilities()&&obj<limit) { 
-          problemStatus=0;
+        if (!smallModel_->numberPrimalInfeasibilities() && obj < limit) {
+          problemStatus = 0;
 #if 0
           ClpSimplex temp = *smallModel_;
@@ -2586 +2567 @@
           assert (temp.problemStatus()==0&&temp.objectiveValue()<limit);
 #endif
-        } else if (problemStatus==10) {
-          problemStatus=3;
+        } else if (problemStatus == 10) {
+          problemStatus = 3;
         } else if (!smallModel_->numberPrimalInfeasibilities()) {
-          problemStatus=1; // infeasible
-        } 
+          problemStatus = 1; // infeasible
+        }
       } else {
         // can't say much
         //if (problemStatus==3)
         //smallModel_->computeObjectiveValue();
-        lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
-        problemStatus=3;
+        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
+        problemStatus = 3;
       }
     } else if (!problemStatus) {
-      if (smallModel_->isDualObjectiveLimitReached()) 
-        problemStatus=1; // infeasible
-    }
-    if (status&&!problemStatus) {
-      problemStatus=3; // can't be sure
-      lastAlgorithm_=1;
-    }
-    if (problemStatus<0)
-      problemStatus=3;
+      if (smallModel_->isDualObjectiveLimitReached())
+        problemStatus = 1; // infeasible
+    }
+    if (status && !problemStatus) {
+      problemStatus = 3; // can't be sure
+      lastAlgorithm_ = 1;
+    }
+    if (problemStatus < 0)
+      problemStatus = 3;
     modelPtr_->setProblemStatus(problemStatus);
-    modelPtr_->setObjectiveValue(obj*modelPtr_->optimizationDirection());
+    modelPtr_->setObjectiveValue(obj * modelPtr_->optimizationDirection());
     modelPtr_->setSumDualInfeasibilities(smallModel_->sumDualInfeasibilities());
     modelPtr_->setNumberDualInfeasibilities(smallModel_->numberDualInfeasibilities());
     modelPtr_->setSumPrimalInfeasibilities(smallModel_->sumPrimalInfeasibilities());
     modelPtr_->setNumberPrimalInfeasibilities(smallModel_->numberPrimalInfeasibilities());
-    double * solution = modelPtr_->primalColumnSolution();
-    const double * solution2 = smallModel_->solutionRegion();
-    double * djs = modelPtr_->dualColumnSolution();
+    double *solution = modelPtr_->primalColumnSolution();
+    const double *solution2 = smallModel_->solutionRegion();
+    double *djs = modelPtr_->dualColumnSolution();
     if (!columnScale) {
-      for (i=0;i<numberColumns2;i++) {
+      for (i = 0; i < numberColumns2; i++) {
         int iColumn = whichColumn[i];
-        solution[iColumn]= solution2[i];
-        lowerSmallReal[i]=saveLowerOriginal[iColumn];
-        upperSmallReal[i]=saveUpperOriginal[iColumn];
+        solution[iColumn] = solution2[i];
+        lowerSmallReal[i] = saveLowerOriginal[iColumn];
+        upperSmallReal[i] = saveUpperOriginal[iColumn];
       }
     } else {
-      for (i=0;i<numberColumns2;i++) {
+      for (i = 0; i < numberColumns2; i++) {
         int iColumn = whichColumn[i];
-        solution[iColumn]= solution2[i]*columnScale[i];
-        lowerSmallReal[i]=saveLowerOriginal[iColumn];
-        upperSmallReal[i]=saveUpperOriginal[iColumn];
+        solution[iColumn] = solution2[i] * columnScale[i];
+        lowerSmallReal[i] = saveLowerOriginal[iColumn];
+        upperSmallReal[i] = saveUpperOriginal[iColumn];
       }
     }
     // compute duals and djs
-    double * dual = modelPtr_->dualRowSolution();
-    const double * dual2 = smallModel_->dualRowSolution();
+    double *dual = modelPtr_->dualRowSolution();
+    const double *dual2 = smallModel_->dualRowSolution();
     if (!rowScale) {
-      for (i=0;i<numberRows2;i++) {
+      for (i = 0; i < numberRows2; i++) {
         int iRow = whichRow[i];
-        dual[iRow]= dual2[i];
+        dual[iRow] = dual2[i];
       }
     } else {
-      for (i=0;i<numberRows2;i++) {
+      for (i = 0; i < numberRows2; i++) {
         int iRow = whichRow[i];
-        dual[iRow]= dual2[i]*rowScale[i];
-      }
-    }
-    memcpy(djs,modelPtr_->objective(),numberColumns*sizeof(double));
-    modelPtr_->clpMatrix()->transposeTimes(-1.0,dual,djs);
+        dual[iRow] = dual2[i] * rowScale[i];
+      }
+    }
+    memcpy(djs, modelPtr_->objective(), numberColumns * sizeof(double));
+    modelPtr_->clpMatrix()->transposeTimes(-1.0, dual, djs);
     // could combine with loop above
-    if (modelPtr_==smallModel_)
+    if (modelPtr_ == smallModel_)
       modelPtr_->computeObjectiveValue();
-    if (problemStatus==1&&smallModel_->ray_) {
-      delete [] modelPtr_->ray_;
+    if (problemStatus == 1 && smallModel_->ray_) {
+      delete[] modelPtr_->ray_;
       // get ray to full problem
       int numberRows = modelPtr_->numberRows();
       int numberRows2 = smallModel_->numberRows();
-      int nCopy = 3*numberRows+2*numberColumns;
+      int nCopy = 3 * numberRows + 2 * numberColumns;
       int nBound = whichRow[nCopy];
-      double * ray = new double [numberRows];
-      memset(ray,0,numberRows*sizeof(double));
+      double *ray = new double[numberRows];
+      memset(ray, 0, numberRows * sizeof(double));
       for (int i = 0; i < numberRows2; i++) {
-        int iRow = whichRow[i];
-        ray[iRow] = smallModel_->ray_[i];
+        int iRow = whichRow[i];
+        ray[iRow] = smallModel_->ray_[i];
       }
       // Column copy of matrix
-      const double * element = getMatrixByCol()->getElements();
-      const int * row = getMatrixByCol()->getIndices();
-      const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
-      const int * columnLength = getMatrixByCol()->getVectorLengths();
+      const double *element = getMatrixByCol()->getElements();
+      const int *row = getMatrixByCol()->getIndices();
+      const CoinBigIndex *columnStart = getMatrixByCol()->getVectorStarts();
+      const int *columnLength = getMatrixByCol()->getVectorLengths();
       // translate
       for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
-        int iRow = whichRow[jRow];
-        int iColumn = whichRow[jRow+numberRows];
-        if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
-          double value = 0.0;
-          double sum = 0.0;
-          for (CoinBigIndex j = columnStart[iColumn];
-               j < columnStart[iColumn] + columnLength[iColumn]; j++) {
-            if (iRow == row[j]) {
-              value = element[j];
-            } else {
-              sum += ray[row[j]]*element[j];
-            }
-          }
-          ray[iRow] = -sum / value;
-        }
-      }
-      for (int i=0;i<modelPtr_->numberColumns_;i++) {
-        if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
-            modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
-          modelPtr_->setStatus(i,ClpSimplex::isFixed);
-      }
-      modelPtr_->ray_=ray;
+        int iRow = whichRow[jRow];
+        int iColumn = whichRow[jRow + numberRows];
+        if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
+          double value = 0.0;
+          double sum = 0.0;
+          for (CoinBigIndex j = columnStart[iColumn];
+               j < columnStart[iColumn] + columnLength[iColumn]; j++) {
+            if (iRow == row[j]) {
+              value = element[j];
+            } else {
+              sum += ray[row[j]] * element[j];
+            }
+          }
+          ray[iRow] = -sum / value;
+        }
+      }
+      for (int i = 0; i < modelPtr_->numberColumns_; i++) {
+        if (modelPtr_->getStatus(i) != ClpSimplex::basic && modelPtr_->columnLower_[i] == modelPtr_->columnUpper_[i])
+          modelPtr_->setStatus(i, ClpSimplex::isFixed);
+      }
+      modelPtr_->ray_ = ray;
       //delete [] smallModel_->ray_;
       //smallModel_->ray_=NULL;
-      modelPtr_->directionOut_=smallModel_->directionOut_;
-      lastAlgorithm_=2; // dual
+      modelPtr_->directionOut_ = smallModel_->directionOut_;
+      lastAlgorithm_ = 2; // dual
     }
 #if 1
-    if (status&&!problemStatus) {
-      memset(modelPtr_->primalRowSolution(),0,numberRows*sizeof(double));
-      modelPtr_->clpMatrix()->times(1.0,solution,modelPtr_->primalRowSolution());
+    if (status && !problemStatus) {
+      memset(modelPtr_->primalRowSolution(), 0, numberRows * sizeof(double));
+      modelPtr_->clpMatrix()->times(1.0, solution, modelPtr_->primalRowSolution());
       modelPtr_->checkSolutionInternal();
       //modelPtr_->setLogLevel(1);
@@ -2709 +2689 @@
       //modelPtr_->clpMatrix()->times(1.0,solution,modelPtr_->primalRowSolution());
       //modelPtr_->checkSolutionInternal();
-      assert (!modelPtr_->problemStatus());
+      assert(!modelPtr_->problemStatus());
     }
 #endif
     modelPtr_->setNumberIterations(smallModel_->numberIterations());
     // and back bounds
-    CoinMemcpyN(saveLower,number,smallModel_->lowerRegion());
-    CoinMemcpyN(saveUpper,number,smallModel_->upperRegion());
+    CoinMemcpyN(saveLower, number, smallModel_->lowerRegion());
+    CoinMemcpyN(saveUpper, number, smallModel_->upperRegion());
   }
   if (savedObjective) {
     // fix up
-    modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
+    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
-    modelPtr_->objective_=savedObjective;
+    modelPtr_->objective_ = savedObjective;
     if (!modelPtr_->problemStatus_) {
-      CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
-      CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
-      if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
-        CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
+      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
+      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
+        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
       modelPtr_->computeObjectiveValue();
     }
   }
-  modelPtr_->setIntParam(ClpMaxNumIteration,itlimOrig_);
+  modelPtr_->setIntParam(ClpMaxNumIteration, itlimOrig_);
 }
 
@@ -2736 +2716 @@
 {
 #ifdef CLEAN_HOT_START
-  if ((specialOptions_&65536)!=0) {
+  if ((specialOptions_ & 65536) != 0) {
     modelPtr_->setLogLevel(saveData_.scalingFlag_);
     modelPtr_->deleteRim(0);
-    if (lastNumberRows_<0) {
+    if (lastNumberRows_ < 0) {
       specialOptions_ |= 131072;
-      lastNumberRows_ = -1 -lastNumberRows_;
+      lastNumberRows_ = -1 - lastNumberRows_;
       if (modelPtr_->rowScale_) {
-        if (modelPtr_->rowScale_!=rowScale_.array()) {
-          delete [] modelPtr_->rowScale_;
-          delete [] modelPtr_->columnScale_;
-        }
-        modelPtr_->rowScale_=NULL;
-        modelPtr_->columnScale_=NULL;
+        if (modelPtr_->rowScale_ != rowScale_.array()) {
+          delete[] modelPtr_->rowScale_;
+          delete[] modelPtr_->columnScale_;
+        }
+        modelPtr_->rowScale_ = NULL;
+        modelPtr_->columnScale_ = NULL;
       }
     }
     delete factorization_;
-    delete [] spareArrays_;
-    smallModel_=NULL;
-    spareArrays_=NULL;
-    factorization_=NULL;
-    delete [] rowActivity_;
-    delete [] columnActivity_;
-    rowActivity_=NULL;
-    columnActivity_=NULL;
+    delete[] spareArrays_;
+    smallModel_ = NULL;
+    spareArrays_ = NULL;
+    factorization_ = NULL;
+    delete[] rowActivity_;
+    delete[] columnActivity_;
+    rowActivity_ = NULL;
+    columnActivity_ = NULL;
     return;
   }
 #endif
-  if (smallModel_==NULL) {
+  if (smallModel_ == NULL) {
     setWarmStart(ws_);
     int numberRows = modelPtr_->numberRows();
     int numberColumns = modelPtr_->numberColumns();
-    CoinMemcpyN(           rowActivity_,numberRows,modelPtr_->primalRowSolution());
-    CoinMemcpyN(columnActivity_,numberColumns,modelPtr_->primalColumnSolution());
+    CoinMemcpyN(rowActivity_, numberRows, modelPtr_->primalRowSolution());
+    CoinMemcpyN(columnActivity_, numberColumns, modelPtr_->primalColumnSolution());
     delete ws_;
     ws_ = NULL;
   } else {
 #ifndef KEEP_SMALL
-    if (smallModel_!=modelPtr_)
+    if (smallModel_ != modelPtr_)
       delete smallModel_;
-    smallModel_=NULL;
+    smallModel_ = NULL;
 #else
-    if (smallModel_==modelPtr_) {
-      smallModel_=NULL;
+    if (smallModel_ == modelPtr_) {
+      smallModel_ = NULL;
     } else if (smallModel_) {
-      if(!spareArrays_) {
-        delete smallModel_;
-        smallModel_=NULL;
-        delete factorization_;
-        factorization_=NULL;
+      if (!spareArrays_) {
+        delete smallModel_;
+        smallModel_ = NULL;
+        delete factorization_;
+        factorization_ = NULL;
       } else {
-        static_cast<ClpSimplexDual *> (smallModel_)->cleanupAfterStrongBranching( factorization_);
-        if ((smallModel_->specialOptions_&4096)==0) {
-          delete factorization_;
-        }
+        static_cast< ClpSimplexDual * >(smallModel_)->cleanupAfterStrongBranching(factorization_);
+        if ((smallModel_->specialOptions_ & 4096) == 0) {
+          delete factorization_;
+        }
       }
     }
@@ -2795 +2775 @@
     //delete [] spareArrays_;
     //spareArrays_=NULL;
-    factorization_=NULL;
-  }
-  delete [] rowActivity_;
-  delete [] columnActivity_;
-  rowActivity_=NULL;
-  columnActivity_=NULL;
+    factorization_ = NULL;
+  }
+  delete[] rowActivity_;
+  delete[] columnActivity_;
+  rowActivity_ = NULL;
+  columnActivity_ = NULL;
   // Make sure whatsChanged not out of sync
   if (!modelPtr_->columnUpperWork_)
     modelPtr_->whatsChanged_ &= ~0xffff;
-  modelPtr_->specialOptions_ = saveData_.specialOptions_; 
-}
-
-#ifdef CONFLICT_CUTS 
+  modelPtr_->specialOptions_ = saveData_.specialOptions_;
+}
+
+#ifdef CONFLICT_CUTS
 // Return a conflict analysis cut from small model
-OsiRowCut * 
-OsiClpSolverInterface::smallModelCut(const double * originalLower, const double * originalUpper,
-                                     int numberRowsAtContinuous,const int * whichGenerator,
-                                     int typeCut)
-{
-  if(smallModel_&&smallModel_->ray_) {
+OsiRowCut *
+OsiClpSolverInterface::smallModelCut(const double *originalLower, const double *originalUpper,
+  int numberRowsAtContinuous, const int *whichGenerator,
+  int typeCut)
+{
+  if (smallModel_ && smallModel_->ray_) {
     //printf("Could do small cut\n");
     int numberRows = modelPtr_->numberRows();
@@ -2820 +2800 @@
     int numberColumns = modelPtr_->numberColumns();
     int numberColumns2 = smallModel_->numberColumns();
-    double * arrayD = reinterpret_cast<double *> (spareArrays_);
-    double * saveSolution = arrayD+1;
-    double * saveLower = saveSolution + (numberRows+numberColumns);
-    double * saveUpper = saveLower + (numberRows+numberColumns);
-    double * saveObjective = saveUpper + (numberRows+numberColumns);
-    double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
-    double * saveUpperOriginal = saveLowerOriginal + numberColumns;
+    double *arrayD = reinterpret_cast< double * >(spareArrays_);
+    double *saveSolution = arrayD + 1;
+    double *saveLower = saveSolution + (numberRows + numberColumns);
+    double *saveUpper = saveLower + (numberRows + numberColumns);
+    double *saveObjective = saveUpper + (numberRows + numberColumns);
+    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
+    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     //double * lowerOriginal = modelPtr_->columnLower();
     //double * upperOriginal = modelPtr_->columnUpper();
-    int * savePivot = reinterpret_cast<int *> (saveUpperOriginal + numberColumns);
-    int * whichRow = savePivot+numberRows;
-    int * whichColumn = whichRow + 3*numberRows;
-    int nCopy = 3*numberRows+2*numberColumns;
+    int *savePivot = reinterpret_cast< int * >(saveUpperOriginal + numberColumns);
+    int *whichRow = savePivot + numberRows;
+    int *whichColumn = whichRow + 3 * numberRows;
+    int nCopy = 3 * numberRows + 2 * numberColumns;
     int nBound = whichRow[nCopy];
-    if (smallModel_->sequenceOut_>=0&&smallModel_->sequenceOut_<numberColumns2)
+    if (smallModel_->sequenceOut_ >= 0 && smallModel_->sequenceOut_ < numberColumns2)
       modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
     else
-      modelPtr_->sequenceOut_ = modelPtr_->numberColumns_+whichRow[smallModel_->sequenceOut_];
-    unsigned char * saveStatus = CoinCopyOfArray(modelPtr_->status_,
-                                                 numberRows+numberColumns);
+      modelPtr_->sequenceOut_ = modelPtr_->numberColumns_ + whichRow[smallModel_->sequenceOut_];
+    unsigned char *saveStatus = CoinCopyOfArray(modelPtr_->status_,
+      numberRows + numberColumns);
     // get ray to full problem
     for (int i = 0; i < numberColumns2; i++) {
@@ -2845 +2825 @@
       modelPtr_->setStatus(iColumn, smallModel_->getStatus(i));
     }
-    double * ray = new double [numberRows+numberColumns2+numberColumns];
-    char * mark = new char [numberRows];
-    memset(ray,0,(numberRows+numberColumns2+numberColumns)*sizeof(double));
-    double * smallFarkas = ray+numberRows;
-    double * farkas = smallFarkas+numberColumns2;
-    double * saveScale = smallModel_->rowScale_;
-    smallModel_->rowScale_=NULL;
-    smallModel_->transposeTimes(1.0,smallModel_->ray_,smallFarkas);
-    smallModel_->rowScale_=saveScale;
-    for (int i=0;i<numberColumns2;i++)
-      farkas[whichColumn[i]]=smallFarkas[i];
-    memset(mark,0,numberRows);
+    double *ray = new double[numberRows + numberColumns2 + numberColumns];
+    char *mark = new char[numberRows];
+    memset(ray, 0, (numberRows + numberColumns2 + numberColumns) * sizeof(double));
+    double *smallFarkas = ray + numberRows;
+    double *farkas = smallFarkas + numberColumns2;
+    double *saveScale = smallModel_->rowScale_;
+    smallModel_->rowScale_ = NULL;
+    smallModel_->transposeTimes(1.0, smallModel_->ray_, smallFarkas);
+    smallModel_->rowScale_ = saveScale;
+    for (int i = 0; i < numberColumns2; i++)
+      farkas[whichColumn[i]] = smallFarkas[i];
+    memset(mark, 0, numberRows);
     for (int i = 0; i < numberRows2; i++) {
       int iRow = whichRow[i];
       modelPtr_->setRowStatus(iRow, smallModel_->getRowStatus(i));
       ray[iRow] = smallModel_->ray_[i];
-      mark[iRow]=1;
+      mark[iRow] = 1;
     }
     // Column copy of matrix
-    const double * element = getMatrixByCol()->getElements();
-    const int * row = getMatrixByCol()->getIndices();
-    const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
-    const int * columnLength = getMatrixByCol()->getVectorLengths();
+    const double *element = getMatrixByCol()->getElements();
+    const int *row = getMatrixByCol()->getIndices();
+    const CoinBigIndex *columnStart = getMatrixByCol()->getVectorStarts();
+    const int *columnLength = getMatrixByCol()->getVectorLengths();
     // pick up small pivot row
     int pivotRow = smallModel_->spareIntArray_[3];
     // translate
-    if (pivotRow>=0)
-      pivotRow=whichRow[pivotRow];
-    modelPtr_->spareIntArray_[3]=pivotRow;
+    if (pivotRow >= 0)
+      pivotRow = whichRow[pivotRow];
+    modelPtr_->spareIntArray_[3] = pivotRow;
     for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
       int iRow = whichRow[jRow];
-      int iColumn = whichRow[jRow+numberRows];
+      int iColumn = whichRow[jRow + numberRows];
       if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
-        double value = 0.0;
-        double sum = 0.0;
-        for (CoinBigIndex j = columnStart[iColumn];
-             j < columnStart[iColumn] + columnLength[iColumn]; j++) {
-          if (iRow == row[j]) {
-            value = element[j];
-          } else if (mark[row[j]]) {
-            sum += ray[row[j]]*element[j];
-          }
-        }
-        double target=farkas[iColumn];
-        if (iRow!=pivotRow) {
-          ray[iRow] = (target-sum) / value;
-        } else {
-          printf("what now - direction %d wanted %g sum %g value %g\n",
-                 smallModel_->directionOut_,ray[iRow],
-                 sum,value);
-        }
-        mark[iRow]=1;
-      }
-    }
-    delete [] mark;
-    for (int i=0;i<modelPtr_->numberColumns_;i++) {
-      if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
-          modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
-        modelPtr_->setStatus(i,ClpSimplex::isFixed);
+        double value = 0.0;
+        double sum = 0.0;
+        for (CoinBigIndex j = columnStart[iColumn];
+             j < columnStart[iColumn] + columnLength[iColumn]; j++) {
+          if (iRow == row[j]) {
+            value = element[j];
+          } else if (mark[row[j]]) {
+            sum += ray[row[j]] * element[j];
+          }
+        }
+        double target = farkas[iColumn];
+        if (iRow != pivotRow) {
+          ray[iRow] = (target - sum) / value;
+        } else {
+          printf("what now - direction %d wanted %g sum %g value %g\n",
+            smallModel_->directionOut_, ray[iRow],
+            sum, value);
+        }
+        mark[iRow] = 1;
+      }
+    }
+    delete[] mark;
+    for (int i = 0; i < modelPtr_->numberColumns_; i++) {
+      if (modelPtr_->getStatus(i) != ClpSimplex::basic && modelPtr_->columnLower_[i] == modelPtr_->columnUpper_[i])
+        modelPtr_->setStatus(i, ClpSimplex::isFixed);
     }
 #if 0
@@ -3025 +3004 @@
     }
 #endif
-    modelPtr_->ray_=ray;
-    lastAlgorithm_=2;
-    modelPtr_->directionOut_=smallModel_->directionOut_;
-    OsiRowCut * cut = modelCut(originalLower,originalUpper,
-                               numberRowsAtContinuous,whichGenerator,typeCut);
+    modelPtr_->ray_ = ray;
+    lastAlgorithm_ = 2;
+    modelPtr_->directionOut_ = smallModel_->directionOut_;
+    OsiRowCut *cut = modelCut(originalLower, originalUpper,
+      numberRowsAtContinuous, whichGenerator, typeCut);
     smallModel_->deleteRay();
-    memcpy(modelPtr_->status_,saveStatus,numberRows+numberColumns);
-    delete [] saveStatus;
+    memcpy(modelPtr_->status_, saveStatus, numberRows + numberColumns);
+    delete[] saveStatus;
     if (cut) {
       //printf("got small cut\n");
@@ -3043 +3022 @@
   }
 }
-static int debugMode=0;
+static int debugMode = 0;
 // Return a conflict analysis cut from model
 //      If type is 0 then genuine cut, if 1 then only partially processed
-OsiRowCut * 
-OsiClpSolverInterface::modelCut(const double * originalLower, const double * originalUpper,
-                                int numberRowsAtContinuous,const int * whichGenerator,
-                                int typeCut)
-{
-  OsiRowCut * cut=NULL;
+OsiRowCut *
+OsiClpSolverInterface::modelCut(const double *originalLower, const double *originalUpper,
+  int numberRowsAtContinuous, const int *whichGenerator,
+  int typeCut)
+{
+  OsiRowCut *cut = NULL;
   //return NULL;
-  if(modelPtr_->ray_) {
-    if (lastAlgorithm_==2) {
+  if (modelPtr_->ray_) {
+    if (lastAlgorithm_ == 2) {
       //printf("Could do normal cut\n");
       // could use existing arrays
-      int numberRows=modelPtr_->numberRows_;
-      int numberColumns=modelPtr_->numberColumns_;
-      double * farkas = new double [2*numberColumns+numberRows];
-      double * bound = farkas + numberColumns;
-      double * effectiveRhs = bound + numberColumns;
-      /*const*/ double * ray = modelPtr_->ray_;
+      int numberRows = modelPtr_->numberRows_;
+      int numberColumns = modelPtr_->numberColumns_;
+      double *farkas = new double[2 * numberColumns + numberRows];
+      double *bound = farkas + numberColumns;
+      double *effectiveRhs = bound + numberColumns;
+      /*const*/ double *ray = modelPtr_->ray_;
       // have to get rid of local cut rows
       whichGenerator -= numberRowsAtContinuous;
-      int badRows=0;
-      for (int iRow=numberRowsAtContinuous;iRow<numberRows;iRow++) {
-        int iType=whichGenerator[iRow];
-        if ((iType>=0&&iType<20000)) {
-          if (fabs(ray[iRow])>1.0e-10) {
-            badRows++;
-          }
-          ray[iRow]=0.0;
-        }
+      int badRows = 0;
+      for (int iRow = numberRowsAtContinuous; iRow < numberRows; iRow++) {
+        int iType = whichGenerator[iRow];
+        if ((iType >= 0 && iType < 20000)) {
+          if (fabs(ray[iRow]) > 1.0e-10) {
+            badRows++;
+          }
+          ray[iRow] = 0.0;
+        }
       }
       ClpSimplex debugModel;
-      if ((debugMode&4)!=0)
-        debugModel = *modelPtr_;
-      if (badRows&&(debugMode&1)!=0) 
-        printf("%d rows from local cuts\n",badRows);
+      if ((debugMode & 4) != 0)
+        debugModel = *modelPtr_;
+      if (badRows && (debugMode & 1) != 0)
+        printf("%d rows from local cuts\n", badRows);
       // get farkas row
-      ClpPackedMatrix * saveMatrix = modelPtr_->scaledMatrix_;
-      double * saveScale = modelPtr_->rowScale_;
-      modelPtr_->rowScale_=NULL;
-      modelPtr_->scaledMatrix_=NULL;
-      memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
-      modelPtr_->transposeTimes(-1.0,ray,farkas);
+      ClpPackedMatrix *saveMatrix = modelPtr_->scaledMatrix_;
+      double *saveScale = modelPtr_->rowScale_;
+      modelPtr_->rowScale_ = NULL;
+      modelPtr_->scaledMatrix_ = NULL;
+      memset(farkas, 0, (2 * numberColumns + numberRows) * sizeof(double));
+      modelPtr_->transposeTimes(-1.0, ray, farkas);
       //const char * integerInformation = modelPtr_->integerType_;
       //assert (integerInformation);
@@ -3092 +3071 @@
       int sequenceOut = modelPtr_->sequenceOut_;
       // Put nonzero bounds in bound
-      const double * columnLower = modelPtr_->columnLower_;
-      const double * columnUpper = modelPtr_->columnUpper_;
-      const double * columnValue = modelPtr_->columnActivity_;
-      int numberBad=0;
-      int nNonzeroBasic=0;
-      for (int i=0;i<numberColumns;i++) {
-        double value = farkas[i];
-        double boundValue=0.0;
-        if (modelPtr_->getStatus(i)==ClpSimplex::basic) {
-          // treat as zero if small
-          if (fabs(value)<1.0e-8) {
-            value=0.0;
-            farkas[i]=0.0;
-          }
-          if (value) {
-            //printf("basic %d direction %d farkas %g\n",
-            //i,modelPtr_->directionOut_,value);
-            nNonzeroBasic++;
-            if (value<0.0) 
-              boundValue=columnLower[i];
-            else
-              boundValue=columnUpper[i];
-          }
-        } else if (fabs(value)>1.0e-10) {
-          if (value<0.0) {
-            if (columnValue[i]>columnLower[i]+1.0e-5&&value<-1.0e-7) {
-              //printf("bad %d alpha %g not at lower\n",i,value);
-              numberBad++;
-            }
-            boundValue=columnLower[i];
-          } else {
-            if (columnValue[i]<columnUpper[i]-1.0e-5&&value>1.0e-7) {
-              //printf("bad %d alpha %g not at upper\n",i,value);
-              numberBad++;
-            }
-            boundValue=columnUpper[i];
-          }
-        }
-        bound[i]=boundValue;
-        if (fabs(boundValue)>1.0e10)
-          numberBad++;
-      }
-      const double * rowLower = modelPtr_->rowLower_;
-      const double * rowUpper = modelPtr_->rowUpper_;
+      const double *columnLower = modelPtr_->columnLower_;
+      const double *columnUpper = modelPtr_->columnUpper_;
+      const double *columnValue = modelPtr_->columnActivity_;
+      int numberBad = 0;
+      int nNonzeroBasic = 0;
+      for (int i = 0; i < numberColumns; i++) {
+        double value = farkas[i];
+        double boundValue = 0.0;
+        if (modelPtr_->getStatus(i) == ClpSimplex::basic) {
+          // treat as zero if small
+          if (fabs(value) < 1.0e-8) {
+            value = 0.0;
+            farkas[i] = 0.0;
+          }
+          if (value) {
+            //printf("basic %d direction %d farkas %g\n",
+            //i,modelPtr_->directionOut_,value);
+            nNonzeroBasic++;
+            if (value < 0.0)
+              boundValue = columnLower[i];
+            else
+              boundValue = columnUpper[i];
+          }
+        } else if (fabs(value) > 1.0e-10) {
+          if (value < 0.0) {
+            if (columnValue[i] > columnLower[i] + 1.0e-5 && value < -1.0e-7) {
+              //printf("bad %d alpha %g not at lower\n",i,value);
+              numberBad++;
+            }
+            boundValue = columnLower[i];
+          } else {
+            if (columnValue[i] < columnUpper[i] - 1.0e-5 && value > 1.0e-7) {
+              //printf("bad %d alpha %g not at upper\n",i,value);
+              numberBad++;
+            }
+            boundValue = columnUpper[i];
+          }
+        }
+        bound[i] = boundValue;
+        if (fabs(boundValue) > 1.0e10)
+          numberBad++;
+      }
+      const double *rowLower = modelPtr_->rowLower_;
+      const double *rowUpper = modelPtr_->rowUpper_;
       //int pivotRow = modelPtr_->spareIntArray_[3];
       //bool badPivot=pivotRow<0;
-      for (int i=0;i<numberRows;i++) {
-        double value = ray[i];
-        double rhsValue=0.0;
-        if (modelPtr_->getRowStatus(i)==ClpSimplex::basic) {
-          // treat as zero if small
-          if (fabs(value)<1.0e-8) {
-            value=0.0;
-            ray[i]=0.0;
-          }
-          if (value) {
-            //printf("row basic %d direction %d ray %g\n",
-            //     i,modelPtr_->directionOut_,value);
-            nNonzeroBasic++;
-            if (value<0.0) 
-              rhsValue=rowLower[i];
-            else
-              rhsValue=rowUpper[i];
-          }
-        } else if (fabs(value)>1.0e-10) {
-          if (value<0.0) 
-            rhsValue=rowLower[i];
-          else
-            rhsValue=rowUpper[i];
-        }
-        effectiveRhs[i]=rhsValue;
+      for (int i = 0; i < numberRows; i++) {
+        double value = ray[i];
+        double rhsValue = 0.0;
+        if (modelPtr_->getRowStatus(i) == ClpSimplex::basic) {
+          // treat as zero if small
+          if (fabs(value) < 1.0e-8) {
+            value = 0.0;
+            ray[i] = 0.0;
+          }
+          if (value) {
+            //printf("row basic %d direction %d ray %g\n",
+            //     i,modelPtr_->directionOut_,value);
+            nNonzeroBasic++;
+            if (value < 0.0)
+              rhsValue = rowLower[i];
+            else
+              rhsValue = rowUpper[i];
+          }
+        } else if (fabs(value) > 1.0e-10) {
+          if (value < 0.0)
+            rhsValue = rowLower[i];
+          else
+            rhsValue = rowUpper[i];
+        }
+        effectiveRhs[i] = rhsValue;
       }
       {
-        double bSum=0.0;
-        for (int i=0;i<numberRows;i++) {
-          bSum += effectiveRhs[i]*ray[i];
-        }
-        //printf("before bounds - bSum %g\n",bSum);
-      }
-      modelPtr_->times(-1.0,bound,effectiveRhs);
-      double bSum=0.0;
-      for (int i=0;i<numberRows;i++) {
-        bSum += effectiveRhs[i]*ray[i];
+        double bSum = 0.0;
+        for (int i = 0; i < numberRows; i++) {
+          bSum += effectiveRhs[i] * ray[i];
+        }
+        //printf("before bounds - bSum %g\n",bSum);
+      }
+      modelPtr_->times(-1.0, bound, effectiveRhs);
+      double bSum = 0.0;
+      for (int i = 0; i < numberRows; i++) {
+        bSum += effectiveRhs[i] * ray[i];
       }
 #if 0
@@ -3215 +3194 @@
 #endif
 #endif
-      modelPtr_->scaledMatrix_=saveMatrix;
-      modelPtr_->rowScale_=saveScale;
-      if (numberBad||bSum>-1.0e-4/*||nNonzeroBasic>1*/ /*||bSum2>-1.0e-4*/) {
-#if PRINT_CONFLICT>1 //ndef NDEBUG
-        printf("bad BOUND bSum %g (bSum2 %g) - %d bad - %d basic\n",
-               bSum,bSum2,numberBad,nNonzeroBasic);
+      modelPtr_->scaledMatrix_ = saveMatrix;
+      modelPtr_->rowScale_ = saveScale;
+      if (numberBad || bSum > -1.0e-4 /*||nNonzeroBasic>1*/ /*||bSum2>-1.0e-4*/) {
+#if PRINT_CONFLICT > 1 //ndef NDEBUG
+        printf("bad BOUND bSum %g (bSum2 %g) - %d bad - %d basic\n",
+          bSum, bSum2, numberBad, nNonzeroBasic);
 #endif
       } else {
-        if (numberColumns<0)
-          debugMode=-numberColumns;
-        if ((debugMode&4)!=0) {
-          int * tempC = new int[numberColumns];
-          double * temp = new double[numberColumns];
-          int n=0;
-          for (int i=0;i<numberColumns;i++) {
-            if (fabs(farkas[i])>1.0e-12) {
-              temp[n]=farkas[i];
-              tempC[n++]=i;
-            }
-          }
-          debugModel.addRow(n,tempC,temp,bSum,bSum);
-          delete [] tempC;
-          delete [] temp;
-        }
-        if ((debugMode&2)!=0) {
-          ClpSimplex dual=*modelPtr_;
-          dual.setLogLevel(63);
-          dual.scaling(0);
-          dual.dual();
-          assert (dual.problemStatus_==1);
-          if (dual.ray_) {
-            double * farkas2 = dual.reducedCost_;
-            // Put nonzero bounds in farkas
-            const double * columnLower = dual.columnLower_;
-            const double * columnUpper = dual.columnUpper_;
-            for (int i=0;i<numberColumns;i++) {
-              farkas2[i]=0.0;
-              if (dual.getStatus(i)==ClpSimplex::atLowerBound||
-                  columnLower[i]==columnUpper[i]) {
-                farkas2[i]=columnLower[i];
-              } else if (dual.getStatus(i)==ClpSimplex::atUpperBound) {
-                farkas2[i]=columnUpper[i];
-              } else if (i==dual.sequenceOut_) {
-                if (dual.directionOut_<0) {
-                  // above upper bound
-                  farkas2[i]=columnUpper[i];
-                } else {
-                  // below lower bound
-                  farkas2[i]=columnLower[i];
-                }
-              } else if (columnLower[i]==columnUpper[i]) {
-                farkas2[i]=columnLower[i];
-              }
-            }
-            double * effectiveRhs2 = dual.rowActivity_;
-            const double * rowLower = dual.rowLower_;
-            const double * rowUpper = dual.rowUpper_;
-            int pivotRow = dual.spareIntArray_[3];
-            for (int i=0;i<numberRows;i++) {
-              if (dual.getRowStatus(i)==ClpSimplex::atLowerBound||
-                  rowUpper[i]==rowLower[i]||
-                  dual.getRowStatus(i)==ClpSimplex::isFixed) {
-                effectiveRhs2[i]=rowLower[i];
-              } else if (dual.getRowStatus(i)==ClpSimplex::atUpperBound) {
-                effectiveRhs2[i]=rowUpper[i];
-              } else {
-                if (dual.getRowStatus(i)!=ClpSimplex::basic) {
-                  assert (rowUpper[i]>1.0e30||rowLower[i]<-1.0e30); // eventually skip
-                  if (rowUpper[i]<1.0e30)
-                    effectiveRhs2[i]=rowUpper[i];
-                  else
-                    effectiveRhs2[i]=rowLower[i];
-                }
-              }
-              if (dual.getRowStatus(i)==ClpSimplex::basic) {
-                effectiveRhs2[i]=0.0;
-                // we should leave pivot row in and use direction for bound
-                if (fabs(dual.ray_[i])>1.0e-8) {
-                  printf("Basic slack value %g on %d - pivotRow %d\n",ray[i],i,pivotRow);
-                  if (i==pivotRow) {
-                    if (dual.directionOut_<0)
-                      effectiveRhs[i]=rowUpper[i];
-                    else 
-                      effectiveRhs[i]=rowLower[i];
-                  } else {
-                    dual.ray_[i]=0.0;
-                  }
-                }
-              }
-            }
-            dual.times(-1.0,farkas2,effectiveRhs2);
-            double bSum2=0.0;
-            for (int i=0;i<numberRows;i++) {
-              bSum2 += effectiveRhs2[i]*dual.ray_[i];
-            }
-            printf("Alternate bSum %g\n",bSum2);
-            memset(farkas2,0,numberColumns*sizeof(double));
-            dual.transposeTimes(-1.0,dual.ray_,farkas2);
-            int nBad=0;
-            double largest=-1.0;
-            double smallest=1.0e30;
-            for (int i=0;i<numberColumns;i++) {
-              //if (fabs(farkas[i])>1.0e-12)
-              //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
-              if (fabs(farkas[i]-farkas2[i])>1.0e-7) {
-                nBad++;
-                largest=CoinMax(largest,fabs(farkas[i]-farkas2[i]));
-                smallest=CoinMin(smallest,fabs(farkas[i]-farkas2[i]));
-                //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
-              }
-            }
-            if (nBad)
-              printf("%d farkas difference %g to %g\n",nBad,smallest,largest);
-            dual.primal();
-            assert (dual.problemStatus_==1);
-            assert (!nBad);
-          }
-        }
-        const char * integerInformation = modelPtr_->integerType_;
-        assert (integerInformation);
-        int * conflict = new int[numberColumns];
-        double * sort = new double [numberColumns];
-        double relax=0.0;
-        int nConflict=0;
-        int nOriginal=0;
-        int nFixed=0;
-        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
-          double thisRelax = 0.0;
-          if (integerInformation[iColumn]) {
-            if ((debugMode&1)!=0)
-            printf("%d status %d %g <= %g <=%g (orig %g, %g) farkas %g\n",
-                   iColumn,modelPtr_->getStatus(iColumn),columnLower[iColumn],
-                   modelPtr_->columnActivity_[iColumn],columnUpper[iColumn],
-                   originalLower[iColumn],originalUpper[iColumn],
-                   farkas[iColumn]);
-            double gap = originalUpper[iColumn]-originalLower[iColumn];
-            if (!gap) 
-              continue;
-            if (gap==columnUpper[iColumn]-columnLower[iColumn])
-              nOriginal++;
-            if (columnUpper[iColumn]==columnLower[iColumn])
-              nFixed++;
-            if (fabs(farkas[iColumn])<1.0e-15) {
-              farkas[iColumn]=0.0;
-              continue;
-            }
-            // temp
-            if (gap>=20000.0&&false) {
-              // can't use
-              if (farkas[iColumn]<0.0) {
-                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
-                // farkas is negative - relax lower bound all way 
-                relax += 
-                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
-              } else {
-                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
-                // farkas is positive - relax upper bound all way 
-                relax += 
-                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
-              }
-              continue;
-            }
-            if (originalLower[iColumn]==columnLower[iColumn]) {
-              // may need to be careful if odd basic (due to local cut)
-              if (farkas[iColumn]>0.0/*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atUpperBound
+        if (numberColumns < 0)
+          debugMode = -numberColumns;
+        if ((debugMode & 4) != 0) {
+          int *tempC = new int[numberColumns];
+          double *temp = new double[numberColumns];
+          int n = 0;
+          for (int i = 0; i < numberColumns; i++) {
+            if (fabs(farkas[i]) > 1.0e-12) {
+              temp[n] = farkas[i];
+              tempC[n++] = i;
+            }
+          }
+          debugModel.addRow(n, tempC, temp, bSum, bSum);
+          delete[] tempC;
+          delete[] temp;
+        }
+        if ((debugMode & 2) != 0) {
+          ClpSimplex dual = *modelPtr_;
+          dual.setLogLevel(63);
+          dual.scaling(0);
+          dual.dual();
+          assert(dual.problemStatus_ == 1);
+          if (dual.ray_) {
+            double *farkas2 = dual.reducedCost_;
+            // Put nonzero bounds in farkas
+            const double *columnLower = dual.columnLower_;
+            const double *columnUpper = dual.columnUpper_;
+            for (int i = 0; i < numberColumns; i++) {
+              farkas2[i] = 0.0;
+              if (dual.getStatus(i) == ClpSimplex::atLowerBound || columnLower[i] == columnUpper[i]) {
+                farkas2[i] = columnLower[i];
+              } else if (dual.getStatus(i) == ClpSimplex::atUpperBound) {
+                farkas2[i] = columnUpper[i];
+              } else if (i == dual.sequenceOut_) {
+                if (dual.directionOut_ < 0) {
+                  // above upper bound
+                  farkas2[i] = columnUpper[i];
+                } else {
+                  // below lower bound
+                  farkas2[i] = columnLower[i];
+                }
+              } else if (columnLower[i] == columnUpper[i]) {
+                farkas2[i] = columnLower[i];
+              }
+            }
+            double *effectiveRhs2 = dual.rowActivity_;
+            const double *rowLower = dual.rowLower_;
+            const double *rowUpper = dual.rowUpper_;
+            int pivotRow = dual.spareIntArray_[3];
+            for (int i = 0; i < numberRows; i++) {
+              if (dual.getRowStatus(i) == ClpSimplex::atLowerBound || rowUpper[i] == rowLower[i] || dual.getRowStatus(i) == ClpSimplex::isFixed) {
+                effectiveRhs2[i] = rowLower[i];
+              } else if (dual.getRowStatus(i) == ClpSimplex::atUpperBound) {
+                effectiveRhs2[i] = rowUpper[i];
+              } else {
+                if (dual.getRowStatus(i) != ClpSimplex::basic) {
+                  assert(rowUpper[i] > 1.0e30 || rowLower[i] < -1.0e30); // eventually skip
+                  if (rowUpper[i] < 1.0e30)
+                    effectiveRhs2[i] = rowUpper[i];
+                  else
+                    effectiveRhs2[i] = rowLower[i];
+                }
+              }
+              if (dual.getRowStatus(i) == ClpSimplex::basic) {
+                effectiveRhs2[i] = 0.0;
+                // we should leave pivot row in and use direction for bound
+                if (fabs(dual.ray_[i]) > 1.0e-8) {
+                  printf("Basic slack value %g on %d - pivotRow %d\n", ray[i], i, pivotRow);
+                  if (i == pivotRow) {
+                    if (dual.directionOut_ < 0)
+                      effectiveRhs[i] = rowUpper[i];
+                    else
+                      effectiveRhs[i] = rowLower[i];
+                  } else {
+                    dual.ray_[i] = 0.0;
+                  }
+                }
+              }
+            }
+            dual.times(-1.0, farkas2, effectiveRhs2);
+            double bSum2 = 0.0;
+            for (int i = 0; i < numberRows; i++) {
+              bSum2 += effectiveRhs2[i] * dual.ray_[i];
+            }
+            printf("Alternate bSum %g\n", bSum2);
+            memset(farkas2, 0, numberColumns * sizeof(double));
+            dual.transposeTimes(-1.0, dual.ray_, farkas2);
+            int nBad = 0;
+            double largest = -1.0;
+            double smallest = 1.0e30;
+            for (int i = 0; i < numberColumns; i++) {
+              //if (fabs(farkas[i])>1.0e-12)
+              //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
+              if (fabs(farkas[i] - farkas2[i]) > 1.0e-7) {
+                nBad++;
+                largest = CoinMax(largest, fabs(farkas[i] - farkas2[i]));
+                smallest = CoinMin(smallest, fabs(farkas[i] - farkas2[i]));
+                //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
+              }
+            }
+            if (nBad)
+              printf("%d farkas difference %g to %g\n", nBad, smallest, largest);
+            dual.primal();
+            assert(dual.problemStatus_ == 1);
+            assert(!nBad);
+          }
+        }
+        const char *integerInformation = modelPtr_->integerType_;
+        assert(integerInformation);
+        int *conflict = new int[numberColumns];
+        double *sort = new double[numberColumns];
+        double relax = 0.0;
+        int nConflict = 0;
+        int nOriginal = 0;
+        int nFixed = 0;
+        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
+          double thisRelax = 0.0;
+          if (integerInformation[iColumn]) {
+            if ((debugMode & 1) != 0)
+              printf("%d status %d %g <= %g <=%g (orig %g, %g) farkas %g\n",
+                iColumn, modelPtr_->getStatus(iColumn), columnLower[iColumn],
+                modelPtr_->columnActivity_[iColumn], columnUpper[iColumn],
+                originalLower[iColumn], originalUpper[iColumn],
+                farkas[iColumn]);
+            double gap = originalUpper[iColumn] - originalLower[iColumn];
+            if (!gap)
+              continue;
+            if (gap == columnUpper[iColumn] - columnLower[iColumn])
+              nOriginal++;
+            if (columnUpper[iColumn] == columnLower[iColumn])
+              nFixed++;
+            if (fabs(farkas[iColumn]) < 1.0e-15) {
+              farkas[iColumn] = 0.0;
+              continue;
+            }
+            // temp
+            if (gap >= 20000.0 && false) {
+              // can't use
+              if (farkas[iColumn] < 0.0) {
+                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
+                // farkas is negative - relax lower bound all way
+                relax += farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
+              } else {
+                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
+                // farkas is positive - relax upper bound all way
+                relax += farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
+              }
+              continue;
+            }
+            if (originalLower[iColumn] == columnLower[iColumn]) {
+              // may need to be careful if odd basic (due to local cut)
+              if (farkas[iColumn] > 0.0 /*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atUpperBound
                                         ||modelPtr_->getStatus(iColumn)==ClpSimplex::isFixed
-                                        ||iColumn==sequenceOut)*/) {
-                // farkas is positive - add to list
-                gap=originalUpper[iColumn]-columnUpper[iColumn];
-                if (gap) {
-                  sort[nConflict]=-farkas[iColumn]*gap;
-                  conflict[nConflict++]=iColumn;
-                }
-                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
-              }
-            } else if (originalUpper[iColumn]==columnUpper[iColumn]) {
-              // may need to be careful if odd basic (due to local cut)
-              if (farkas[iColumn]<0.0/*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atLowerBound
+                                        ||iColumn==sequenceOut)*/
+              ) {
+                // farkas is positive - add to list
+                gap = originalUpper[iColumn] - columnUpper[iColumn];
+                if (gap) {
+                  sort[nConflict] = -farkas[iColumn] * gap;
+                  conflict[nConflict++] = iColumn;
+                }
+                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
+              }
+            } else if (originalUpper[iColumn] == columnUpper[iColumn]) {
+              // may need to be careful if odd basic (due to local cut)
+              if (farkas[iColumn] < 0.0 /*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atLowerBound
                                         ||modelPtr_->getStatus(iColumn)==ClpSimplex::isFixed
-                                        ||iColumn==sequenceOut)*/) {
-                // farkas is negative - add to list
-                gap=columnLower[iColumn]-originalLower[iColumn];
-                if (gap) {
-                  sort[nConflict]=farkas[iColumn]*gap;
-                  conflict[nConflict++]=iColumn;
-                }
-                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
-              }
-            } else {
-              // can't use
-              if (farkas[iColumn]<0.0) {
-                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
-                // farkas is negative - relax lower bound all way 
-                thisRelax = 
-                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
-              } else {
-                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
-                // farkas is positive - relax upper bound all way 
-                thisRelax = 
-                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
-              }
-            }
-          } else {
-            // not integer - but may have been got at
-            double gap = originalUpper[iColumn]-originalLower[iColumn];
-            if (gap>columnUpper[iColumn]-columnLower[iColumn]) {
-              // can't use
-              if (farkas[iColumn]<0.0) {
-                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
-                // farkas is negative - relax lower bound all way 
-                thisRelax = 
-                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
-              } else {
-                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
-                // farkas is positive - relax upper bound all way 
-                thisRelax = 
-                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
-              }
-            }
-          }
-          assert (thisRelax>=0.0);
-          relax += thisRelax;
-        }
-        if (relax+bSum>-1.0e-4||!nConflict) {
-          if (relax+bSum>-1.0e-4) {
-#if PRINT_CONFLICT>1 //ndef NDEBUG
-            printf("General integers relax bSum to %g\n",relax+bSum);
-#endif
-          } else {
+                                        ||iColumn==sequenceOut)*/
+              ) {
+                // farkas is negative - add to list
+                gap = columnLower[iColumn] - originalLower[iColumn];
+                if (gap) {
+                  sort[nConflict] = farkas[iColumn] * gap;
+                  conflict[nConflict++] = iColumn;
+                }
+                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
+              }
+            } else {
+              // can't use
+              if (farkas[iColumn] < 0.0) {
+                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
+                // farkas is negative - relax lower bound all way
+                thisRelax = farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
+              } else {
+                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
+                // farkas is positive - relax upper bound all way
+                thisRelax = farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
+              }
+            }
+          } else {
+            // not integer - but may have been got at
+            double gap = originalUpper[iColumn] - originalLower[iColumn];
+            if (gap > columnUpper[iColumn] - columnLower[iColumn]) {
+              // can't use
+              if (farkas[iColumn] < 0.0) {
+                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
+                // farkas is negative - relax lower bound all way
+                thisRelax = farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
+              } else {
+                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
+                // farkas is positive - relax upper bound all way
+                thisRelax = farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
+              }
+            }
+          }
+          assert(thisRelax >= 0.0);
+          relax += thisRelax;
+        }
+        if (relax + bSum > -1.0e-4 || !nConflict) {
+          if (relax + bSum > -1.0e-4) {
+#if PRINT_CONFLICT > 1 //ndef NDEBUG
+            printf("General integers relax bSum to %g\n", relax + bSum);
+#endif
+          } else {
 #if PRINT_CONFLICT
-            printf("All variables relaxed and still infeasible - what does this mean?\n");
-#endif
-            int nR=0;
-            for (int i=0;i<numberRows;i++) {
-              if (fabs(ray[i])>1.0e-10)
-                nR++;
-              else
-                ray[i]=0.0;
-            }
-            int nC=0;
-            for (int i=0;i<numberColumns;i++) {
-              if (fabs(farkas[i])>1.0e-10)
-                nC++;
-              else
-                farkas[i]=0.0;
-            }
-            if (nR<3&&nC<5) {
-              printf("BAD %d nonzero rows, %d nonzero columns\n",nR,nC);
-            }
-          }
-        } else if (nConflict < 1000) {
-#if PRINT_CONFLICT>1 //ndef NDEBUG
-          if (nConflict<5)
-            printf("BOUNDS violation bSum %g (relaxed %g) - %d at original bounds, %d fixed - %d in conflict\n",bSum,
-                   relax+bSum,nOriginal,nFixed,nConflict);
-#endif
-          CoinSort_2(sort,sort+nConflict,conflict);
-          if ((debugMode&4)!=0) {
-            double * temp = new double[numberColumns];
-            int * tempC = new int[numberColumns];
-            int n=0;
-            for (int j=0;j<nConflict;j++) {
-              int i=conflict[j];
-              if (fabs(farkas[i])>1.0e-12) {
-                temp[n]=farkas[i];
-                tempC[n++]=i;
-              }
-            }
-            debugModel.addRow(n,tempC,temp,bSum,bSum);
-            delete [] tempC;
-            delete [] temp;
-          }
-          int nC=nConflict;
-          for (int i=0;i<nConflict;i++) {
-            int iColumn=conflict[i];
-            if (fabs(sort[i])!=fabs(farkas[iColumn])&&originalUpper[iColumn]==1.0)
-              printf("odd %d %g %d %g\n",i,sort[i],iColumn,farkas[iColumn]);
-          }
-          bSum+=relax;
-          double saveBsum = bSum;
-          // we can't use same values
-          double totalChange=0;
-          while (nConflict) {
-            double last = -sort[nConflict-1];
-            int kConflict=nConflict;
-            while (kConflict) {
-              double change = -sort[kConflict-1];
-              if (change>last+1.0e-5)
-                break;
-              totalChange += change;
-              kConflict--;
-            }
-            if (bSum+totalChange>-1.0e-4)
-              break;
+            printf("All variables relaxed and still infeasible - what does this mean?\n");
+#endif
+            int nR = 0;
+            for (int i = 0; i < numberRows; i++) {
+              if (fabs(ray[i]) > 1.0e-10)
+                nR++;
+              else
+                ray[i] = 0.0;
+            }
+            int nC = 0;
+            for (int i = 0; i < numberColumns; i++) {
+              if (fabs(farkas[i]) > 1.0e-10)
+                nC++;
+              else
+                farkas[i] = 0.0;
+            }
+            if (nR < 3 && nC < 5) {
+              printf("BAD %d nonzero rows, %d nonzero columns\n", nR, nC);
+            }
+          }
+        } else if (nConflict < 1000) {
+#if PRINT_CONFLICT > 1 //ndef NDEBUG
+          if (nConflict < 5)
+            printf("BOUNDS violation bSum %g (relaxed %g) - %d at original bounds, %d fixed - %d in conflict\n", bSum,
+              relax + bSum, nOriginal, nFixed, nConflict);
+#endif
+          CoinSort_2(sort, sort + nConflict, conflict);
+          if ((debugMode & 4) != 0) {
+            double *temp = new double[numberColumns];
+            int *tempC = new int[numberColumns];
+            int n = 0;
+            for (int j = 0; j < nConflict; j++) {
+              int i = conflict[j];
+              if (fabs(farkas[i]) > 1.0e-12) {
+                temp[n] = farkas[i];
+                tempC[n++] = i;
+              }
+            }
+            debugModel.addRow(n, tempC, temp, bSum, bSum);
+            delete[] tempC;
+            delete[] temp;
+          }
+          int nC = nConflict;
+          for (int i = 0; i < nConflict; i++) {
+            int iColumn = conflict[i];
+            if (fabs(sort[i]) != fabs(farkas[iColumn]) && originalUpper[iColumn] == 1.0)
+              printf("odd %d %g %d %g\n", i, sort[i], iColumn, farkas[iColumn]);
+          }
+          bSum += relax;
+          double saveBsum = bSum;
+          // we can't use same values
+          double totalChange = 0;
+          while (nConflict) {
+            double last = -sort[nConflict - 1];
+            int kConflict = nConflict;
+            while (kConflict) {
+              double change = -sort[kConflict - 1];
+              if (change > last + 1.0e-5)
+                break;
+              totalChange += change;
+              kConflict--;
+            }
+            if (bSum + totalChange > -1.0e-4)
+              break;
 #if 0
             //int iColumn=conflict[nConflict-1];
@@ -3517 +3489 @@
             bSum += change;
 #else
-            nConflict=kConflict;
-            bSum += totalChange;
-#endif
-          }
-          if (!nConflict) {
-            int nR=0;
-            for (int i=0;i<numberRows;i++) {
-              if (fabs(ray[i])>1.0e-10)
-                nR++;
-              else
-                ray[i]=0.0;
-            }
-            int nC=0;
-            for (int i=0;i<numberColumns;i++) {
-              if (fabs(farkas[i])>1.0e-10)
-                nC++;
-              else
-                farkas[i]=0.0;
-            }
+            nConflict = kConflict;
+            bSum += totalChange;
+#endif
+          }
+          if (!nConflict) {
+            int nR = 0;
+            for (int i = 0; i < numberRows; i++) {
+              if (fabs(ray[i]) > 1.0e-10)
+                nR++;
+              else
+                ray[i] = 0.0;
+            }
+            int nC = 0;
+            for (int i = 0; i < numberColumns; i++) {
+              if (fabs(farkas[i]) > 1.0e-10)
+                nC++;
+              else
+                farkas[i] = 0.0;
+            }
 #if 1 //PRINT_CONFLICT>1 //ndef NDEBUG
-            {
-              printf("BAD2 - zero nConflict %d nonzero rows, %d nonzero columns\n",nR,nC);
-            }
-#endif
-          }
-          // no point doing if no reduction (or big?) ?
-          if (nConflict<nC+1&&nConflict<100&&nConflict) {
-            cut=new OsiRowCut();
-            cut->setUb(COIN_DBL_MAX);
-            if (!typeCut) {
-              double lo=1.0;
-              for (int i=0;i<nConflict;i++) {
-                int iColumn = conflict[i];
-                if (originalLower[iColumn]==columnLower[iColumn]) {
-                  // must be at least one higher
-                  sort[i]=1.0;
-                  lo += originalLower[iColumn];
-                } else {
-                  // must be at least one lower
-                  sort[i]=-1.0;
-                  lo -= originalUpper[iColumn];
-                }
-              }
-              cut->setLb(lo);
-              cut->setRow(nConflict,conflict,sort);
+            {
+              printf("BAD2 - zero nConflict %d nonzero rows, %d nonzero columns\n", nR, nC);
+            }
+#endif
+          }
+          // no point doing if no reduction (or big?) ?
+          if (nConflict < nC + 1 && nConflict < 100 && nConflict) {
+            cut = new OsiRowCut();
+            cut->setUb(COIN_DBL_MAX);
+            if (!typeCut) {
+              double lo = 1.0;
+              for (int i = 0; i < nConflict; i++) {
+                int iColumn = conflict[i];
+                if (originalLower[iColumn] == columnLower[iColumn]) {
+                  // must be at least one higher
+                  sort[i] = 1.0;
+                  lo += originalLower[iColumn];
+                } else {
+                  // must be at least one lower
+                  sort[i] = -1.0;
+                  lo -= originalUpper[iColumn];
+                }
+              }
+              cut->setLb(lo);
+              cut->setRow(nConflict, conflict, sort);
 #if PRINT_CONFLICT
-              printf("CUT has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
-#endif
-              if ((debugMode&4)!=0) {
-                debugModel.addRow(nConflict,conflict,sort,lo,COIN_DBL_MAX);
-                debugModel.writeMps("bad.mps");
-              }
-            } else {
-              // just save for use later
-              // first take off small
-              int nC2=nC;
-              while (nC2) {
-                //int iColumn=conflict[nConflict-1];