source: stable/2.0/Cbc/src/CbcModel.cpp @ 844

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#include "CbcConfig.h"

#include <string>
//#define CBC_DEBUG 1
//#define CHECK_CUT_COUNTS
//#define CHECK_NODE_FULL
//#define NODE_LOG
//#define GLOBAL_CUTS_JUST_POINTERS
#ifndef CLP_FAST_CODE
#ifdef NDEBUG
#undef NDEBUG
#endif
#endif
#include <cassert>
#include <cmath>
#include <cfloat>

#ifdef COIN_HAS_CLP
// include Presolve from Clp
#include "ClpPresolve.hpp"
#include "OsiClpSolverInterface.hpp"
#endif

#include "CbcEventHandler.hpp"

#include "OsiSolverInterface.hpp"
#include "OsiAuxInfo.hpp"
#include "OsiSolverBranch.hpp"
#include "OsiChooseVariable.hpp"
#include "CoinWarmStartBasis.hpp"
#include "CoinPackedMatrix.hpp"
#include "CoinHelperFunctions.hpp"
#include "CbcBranchActual.hpp"
#include "CbcBranchDynamic.hpp"
#include "CbcHeuristic.hpp"
#include "CbcHeuristicFPump.hpp"
#include "CbcModel.hpp"
#include "CbcTreeLocal.hpp"
#include "CbcStatistics.hpp"
#include "CbcStrategy.hpp"
#include "CbcMessage.hpp"
#include "OsiRowCut.hpp"
#include "OsiColCut.hpp"
#include "OsiRowCutDebugger.hpp"
#include "OsiCuts.hpp"
#include "CbcCountRowCut.hpp"
#include "CbcCutGenerator.hpp"
#include "CbcFeasibilityBase.hpp"
#include "CbcFathom.hpp"
// include Probing
#include "CglProbing.hpp"
// include preprocessing
#include "CglPreProcess.hpp"
#include "CglDuplicateRow.hpp"
#include "CglStored.hpp"

#include "CoinTime.hpp"
#include "CoinMpsIO.hpp"

#include "CbcCompareActual.hpp"
#include "CbcTree.hpp"
//#define CBC_THREAD
#ifdef CBC_THREAD
#include <pthread.h>
#ifndef CLP_FAST_CODE
//#define CBC_THREAD_DEBUG 1
#endif
#ifdef CBC_THREAD_DEBUG 
#ifdef NDEBUG
#undef NDEBUG
#undef assert
#         define assert(expression) {                              \
             if (!(expression)) {                                          \
                throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
                                "", __FILE__, __LINE__);                   \
             }                                                             \
          }
#endif
#endif
// To Pass across to doOneNode
typedef struct {
  CbcModel * baseModel;
  CbcModel * thisModel;
  CbcNode * node; // filled in every time
  CbcNode * createdNode; // filled in every time on return
  pthread_t threadIdOfBase;
  pthread_mutex_t * mutex; // for locking data
  pthread_mutex_t * mutex2; // for waking up threads
  pthread_cond_t * condition2; // for waking up thread
  int returnCode; // -1 available, 0 busy, 1 finished , 2??
  double timeLocked;
  double timeWaitingToLock;
  double timeWaitingToStart;
  double timeInThread;
  int numberTimesLocked;
  int numberTimesUnlocked;
  int numberTimesWaitingToStart;
  int saveStuff[2];
  struct timespec absTime;
  bool locked;
#if CBC_THREAD_DEBUG
  int threadNumber;
#endif
} threadStruct;
static void * doNodesThread(void * voidInfo);
static void * doCutsThread(void * voidInfo);
#endif
/* Various functions local to CbcModel.cpp */

namespace {

//-------------------------------------------------------------------
// Returns the greatest common denominator of two 
// positive integers, a and b, found using Euclid's algorithm 
//-------------------------------------------------------------------
static int gcd(int a, int b) 
{
  int remainder = -1;
  // make sure a<=b (will always remain so)
  if(a > b) {
    // Swap a and b
    int temp = a;
    a = b;
    b = temp;
  }
  // if zero then gcd is nonzero (zero may occur in rhs of packed)
  if (!a) {
    if (b) {
      return b;
    } else {
      printf("**** gcd given two zeros!!\n");
      abort();
    }
  }
  while (remainder) {
    remainder = b % a;
    b = a;
    a = remainder;
  }
  return b;
}



#ifdef CHECK_NODE_FULL

/*
  Routine to verify that tree linkage is correct. The invariant that is tested
  is

  reference count = (number of actual references) + (number of branches left)

  The routine builds a set of paired arrays, info and count, by traversing the
  tree. Each CbcNodeInfo is recorded in info, and the number of times it is
  referenced (via the parent field) is recorded in count. Then a final check is
  made to see if the numberPointingToThis_ field agrees.
*/

void verifyTreeNodes (const CbcTree * branchingTree, const CbcModel &model)

{if (model.getNodeCount()==661) return;  printf("*** CHECKING tree after %d nodes\n",model.getNodeCount()) ;
 
  int j ;
  int nNodes = branchingTree->size() ;
# define MAXINFO 1000
  int *count = new int [MAXINFO] ;
  CbcNodeInfo **info = new CbcNodeInfo*[MAXINFO] ;
  int nInfo = 0 ;
/*
  Collect all CbcNodeInfo objects in info, by starting from each live node and
  traversing back to the root. Nodes in the live set should have unexplored
  branches remaining.

  TODO: The `while (nodeInfo)' loop could be made to break on reaching a
        common ancester (nodeInfo is found in info[k]). Alternatively, the
        check could change to signal an error if nodeInfo is not found above a
        common ancestor.
*/
  for (j = 0 ; j < nNodes ; j++)
  { CbcNode *node = branchingTree->nodePointer(j) ;
  if (!node)
    continue;
    CbcNodeInfo *nodeInfo = node->nodeInfo() ; 
    int change = node->nodeInfo()->numberBranchesLeft() ;
    assert(change) ;
    while (nodeInfo)
    { int k ;
      for (k = 0 ; k < nInfo ; k++)
      { if (nodeInfo == info[k]) break ; }
      if (k == nInfo)
      { assert(nInfo < MAXINFO) ;
        nInfo++ ;
        info[k] = nodeInfo ;
        count[k] = 0 ; }
      nodeInfo = nodeInfo->parent() ; } }
/*
  Walk the info array. For each nodeInfo, look up its parent in info and
  increment the corresponding count.
*/
  for (j = 0 ; j < nInfo ; j++)
  { CbcNodeInfo *nodeInfo = info[j] ;
    nodeInfo = nodeInfo->parent() ;
    if (nodeInfo)
    { int k ;
      for (k = 0 ; k < nInfo ; k++)
      { if (nodeInfo == info[k]) break ; }
      assert (k < nInfo) ;
      count[k]++ ; } }
/*
  Walk the info array one more time and check that the invariant holds. The
  number of references (numberPointingToThis()) should equal the sum of the
  number of actual references (held in count[]) plus the number of potential
  references (unexplored branches, numberBranchesLeft()).
*/
  for (j = 0;j < nInfo;j++) {
    CbcNodeInfo * nodeInfo = info[j] ;
    if (nodeInfo) {
      int k ;
      for (k = 0;k < nInfo;k++)
        if (nodeInfo == info[k])
          break ;
      printf("Nodeinfo %x - %d left, %d count\n",
             nodeInfo,
             nodeInfo->numberBranchesLeft(),
             nodeInfo->numberPointingToThis()) ;
      assert(nodeInfo->numberPointingToThis() ==
             count[k]+nodeInfo->numberBranchesLeft()) ; } }

  delete [] count ;
  delete [] info ;
  
  return ; }

#endif  /* CHECK_NODE_FULL */



#ifdef CHECK_CUT_COUNTS

/*
  Routine to verify that cut reference counts are correct.
*/
void verifyCutCounts (const CbcTree * branchingTree, CbcModel &model)

{ printf("*** CHECKING cuts after %d nodes\n",model.getNodeCount()) ;

  int j ;
  int nNodes = branchingTree->size() ;

/*
  cut.tempNumber_ exists for the purpose of doing this verification. Clear it
  in all cuts. We traverse the tree by starting from each live node and working
  back to the root. At each CbcNodeInfo, check for cuts.
*/
  for (j = 0 ; j < nNodes ; j++)
  { CbcNode *node = branchingTree->nodePointer(j) ;
    CbcNodeInfo * nodeInfo = node->nodeInfo() ;
    assert (node->nodeInfo()->numberBranchesLeft()) ;
    while (nodeInfo)
    { int k ;
      for (k = 0 ; k < nodeInfo->numberCuts() ; k++)
      { CbcCountRowCut *cut = nodeInfo->cuts()[k] ;
        if (cut) cut->tempNumber_ = 0; }
      nodeInfo = nodeInfo->parent() ; } }
/*
  Walk the live set again, this time collecting the list of cuts in use at each
  node. addCuts1 will collect the cuts in model.addedCuts_. Take into account
  that when we recreate the basis for a node, we compress out the slack cuts.
*/
  for (j = 0 ; j < nNodes ; j++)
  { CoinWarmStartBasis *debugws = model.getEmptyBasis() ;
    CbcNode *node = branchingTree->nodePointer(j) ;
    CbcNodeInfo *nodeInfo = node->nodeInfo(); 
    int change = node->nodeInfo()->numberBranchesLeft() ;
    printf("Node %d %x (info %x) var %d way %d obj %g",j,node,
           node->nodeInfo(),node->columnNumber(),node->way(),
           node->objectiveValue()) ;

    model.addCuts1(node,debugws) ;

    int i ;
    int numberRowsAtContinuous = model.numberRowsAtContinuous() ;
    CbcCountRowCut **addedCuts = model.addedCuts() ;
    for (i = 0 ; i < model.currentNumberCuts() ; i++)
    { CoinWarmStartBasis::Status status = 
        debugws->getArtifStatus(i+numberRowsAtContinuous) ;
      if (status != CoinWarmStartBasis::basic && addedCuts[i])
      { addedCuts[i]->tempNumber_ += change ; } }

    while (nodeInfo)
    { nodeInfo = nodeInfo->parent() ;
      if (nodeInfo) printf(" -> %x",nodeInfo); }
    printf("\n") ;
    delete debugws ; }
/*
  The moment of truth: We've tallied up the references by direct scan of the
  search tree. Check for agreement with the count in the cut.

  TODO: Rewrite to check and print mismatch only when tempNumber_ == 0?
*/
  for (j = 0 ; j < nNodes ; j++)
  { CbcNode *node = branchingTree->nodePointer(j) ;
    CbcNodeInfo *nodeInfo = node->nodeInfo(); 
    while (nodeInfo)
    { int k ;
      for (k = 0 ; k < nodeInfo->numberCuts() ; k++)
      { CbcCountRowCut *cut = nodeInfo->cuts()[k] ;
        if (cut && cut->tempNumber_ >= 0)
        { if (cut->tempNumber_ != cut->numberPointingToThis()) 
            printf("mismatch %x %d %x %d %d\n",nodeInfo,k,
                    cut,cut->tempNumber_,cut->numberPointingToThis()) ;
          else
            printf("   match %x %d %x %d %d\n", nodeInfo,k,
                   cut,cut->tempNumber_,cut->numberPointingToThis()) ;
          cut->tempNumber_ = -1 ; } }
      nodeInfo = nodeInfo->parent() ; } }

  return ; }

#endif /* CHECK_CUT_COUNTS */


//#define CHECK_CUT_SIZE
#ifdef CHECK_CUT_SIZE

/*
  Routine to verify that cut reference counts are correct.
*/
void verifyCutSize (const CbcTree * branchingTree, CbcModel &model)
{ 

  int j ;
  int nNodes = branchingTree->size() ;
  int totalCuts=0;

/*
  cut.tempNumber_ exists for the purpose of doing this verification. Clear it
  in all cuts. We traverse the tree by starting from each live node and working
  back to the root. At each CbcNodeInfo, check for cuts.
*/
  for (j = 0 ; j < nNodes ; j++) {
    CbcNode *node = branchingTree->nodePointer(j) ;
    CbcNodeInfo * nodeInfo = node->nodeInfo() ;
    assert (node->nodeInfo()->numberBranchesLeft()) ;
    while (nodeInfo) {
      totalCuts += nodeInfo->numberCuts();
      nodeInfo = nodeInfo->parent() ;
    }
  }
  printf("*** CHECKING cuts (size) after %d nodes - %d cuts\n",model.getNodeCount(),totalCuts) ;
  return ;
}

#endif /* CHECK_CUT_SIZE */

}

 /* End unnamed namespace for CbcModel.cpp */


static double trueIncrement=0.0;
void 
CbcModel::analyzeObjective ()
/*
  Try to find a minimum change in the objective function. The first scan
  checks that there are no continuous variables with non-zero coefficients,
  and grabs the largest objective coefficient associated with an unfixed
  integer variable. The second scan attempts to scale up the objective
  coefficients to a point where they are sufficiently close to integer that
  we can pretend they are integer, and calculate a gcd over the coefficients
  of interest. This will be the minimum increment for the scaled coefficients.
  The final action is to scale the increment back for the original coefficients
  and install it, if it's better than the existing value.

  John's note: We could do better than this.

  John's second note - apologies for changing s to z
*/
{ const double *objective = getObjCoefficients() ;
  const double *lower = getColLower() ;
  const double *upper = getColUpper() ;
/*
  Take a first scan to see if there are unfixed continuous variables in the
  objective.  If so, the minimum objective change could be arbitrarily small.
  Also pick off the maximum coefficient of an unfixed integer variable.

  If the objective is found to contain only integer variables, set the
  fathoming discipline to strict.
*/
  double maximumCost = 0.0 ;
  trueIncrement=0.0;
  bool possibleMultiple = true ;
  int iColumn ;
  int numberColumns = getNumCols() ;
  for (iColumn = 0 ; iColumn < numberColumns ; iColumn++)
  { if (upper[iColumn] > lower[iColumn]+1.0e-8)
    { if (isInteger(iColumn)) 
        maximumCost = CoinMax(maximumCost,fabs(objective[iColumn])) ;
      else if (objective[iColumn]) 
        possibleMultiple = false ; } }
  setIntParam(CbcModel::CbcFathomDiscipline,possibleMultiple) ;
/*
  If a nontrivial increment is possible, try and figure it out. We're looking
  for gcd(c<j>) for all c<j> that are coefficients of unfixed integer
  variables. Since the c<j> might not be integers, try and inflate them
  sufficiently that they look like integers (and we'll deflate the gcd
  later).

  2520.0 is used as it is a nice multiple of 2,3,5,7
*/
    if (possibleMultiple&&maximumCost)
    { int increment = 0 ;
      double multiplier = 2520.0 ;
      while (10.0*multiplier*maximumCost < 1.0e8)
        multiplier *= 10.0 ;
    int bigIntegers = 0; // Count of large costs which are integer
    for (iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
      if (upper[iColumn] > lower[iColumn]+1.0e-8) {
        if (isInteger(iColumn)&&objective[iColumn]) {
          double value = fabs(objective[iColumn])*multiplier ;
          if (value <2.1e9) {
            int nearest = (int) floor(value+0.5) ;
            if (fabs(value-floor(value+0.5)) > 1.0e-8)
              { increment = 0 ;
              break ; }
            else if (!increment)
              { increment = nearest ; }
            else
              { increment = gcd(increment,nearest) ; }
          } else {
            // large value - may still be multiple of 1.0
            value = fabs(objective[iColumn]);
            if (fabs(value-floor(value+0.5)) > 1.0e-8) {
              increment=0;
              break;
            } else {
              bigIntegers++;
            }
          }
        }
      }
    }

/*
  If the increment beats the current value for objective change, install it.
*/
      if (increment)
      { double value = increment ;
        double cutoff = getDblParam(CbcModel::CbcCutoffIncrement) ;
        if (bigIntegers) {
          // allow for 1.0
          increment = gcd(increment,(int) multiplier);
          value = increment;
        }
        value /= multiplier ;
        trueIncrement=CoinMax(cutoff,value);;
        if (value*0.999 > cutoff)
        { messageHandler()->message(CBC_INTEGERINCREMENT,
                                          messages())
            << value << CoinMessageEol ;
          setDblParam(CbcModel::CbcCutoffIncrement,value*0.999) ; } } }

  return ; 
}


/**
  \todo
  Normally, it looks like we enter here from command dispatch in the main
  routine, after calling the solver for an initial solution
  (CbcModel::initialSolve, which simply calls the solver's initialSolve
  routine.) The first thing we do is call resolve. Presumably there are
  circumstances where this is nontrivial? There's also a call from
  CbcModel::originalModel (tied up with integer presolve), which should be
  checked.

*/

/*
  The overall flow can be divided into three stages:
    * Prep: Check that the lp relaxation remains feasible at the root. If so,
      do all the setup for B&C.
    * Process the root node: Generate cuts, apply heuristics, and in general do
      the best we can to resolve the problem without B&C.
    * Do B&C search until we hit a limit or exhaust the search tree.
  
  Keep in mind that in general there is no node in the search tree that
  corresponds to the active subproblem. The active subproblem is represented
  by the current state of the model,  of the solver, and of the constraint
  system held by the solver.
*/
void CbcModel::branchAndBound(int doStatistics) 

{
/*
  Capture a time stamp before we start.
*/
  dblParam_[CbcStartSeconds] = CoinCpuTime();
  strongInfo_[0]=0;
  strongInfo_[1]=0;
  strongInfo_[2]=0;
  numberStrongIterations_ = 0;
  // Initialize random seed
  CoinSeedRandom(1234567);
#ifndef NDEBUG
  {
#ifdef COIN_DEVELOP
    double big = 1.0e10;
#else
    double big = 1.0e20;
#endif
    int i;
    int n = solver_->getNumCols();
    const double *lower = solver_->getColLower() ;
    const double *upper = solver_->getColUpper() ;
    for (i=0;i<n;i++) {
      assert (lower[i]<big);
      assert (upper[i]>-big);
    }
    n = solver_->getNumRows();
    lower = solver_->getRowLower() ;
    upper = solver_->getRowUpper() ;
    for (i=0;i<n;i++) {
      assert (lower[i]<big);
      assert (upper[i]>-big);
    }
  }
#endif
  // original solver (only set if pre-processing)
  OsiSolverInterface * originalSolver=NULL;
  int numberOriginalObjects=numberObjects_;
  OsiObject ** originalObject = NULL;
  // Set up strategies
#if 0
  std::string problemName ;
  solver_->getStrParam(OsiProbName,problemName) ;
  if (!strcmp(problemName.c_str(),"PP08A")) solver_->activateRowCutDebugger(problemName.c_str()) ;
#endif
  if (strategy_) {
    // May do preprocessing
    originalSolver = solver_;
    strategy_->setupOther(*this);
    if (strategy_->preProcessState()) {
      // pre-processing done
      if (strategy_->preProcessState()<0) {
        // infeasible
        handler_->message(CBC_INFEAS,messages_)<< CoinMessageEol ;
        status_ = 0 ;
        secondaryStatus_ = 1;
        originalContinuousObjective_ = COIN_DBL_MAX;
        return ; 
      } else if (numberObjects_&&object_) {
        numberOriginalObjects=numberObjects_;
        // redo sequence
        numberIntegers_=0;
        int numberColumns = getNumCols();
        int nOrig = originalSolver->getNumCols();
        CglPreProcess * process = strategy_->process();
        assert (process);
        const int * originalColumns = process->originalColumns();
        // allow for cliques etc
        nOrig = CoinMax(nOrig,originalColumns[numberColumns-1]+1);
        // try and redo debugger
        OsiRowCutDebugger * debugger = const_cast<OsiRowCutDebugger *> (solver_->getRowCutDebuggerAlways());
        if (debugger)
          debugger->redoSolution(numberColumns,originalColumns);
        originalObject = object_;
        // object number or -1
        int * temp = new int[nOrig];
        int iColumn;
        for (iColumn=0;iColumn<nOrig;iColumn++) 
          temp[iColumn]=-1;
        int iObject;
        int nNonInt=0;
        for (iObject=0;iObject<numberOriginalObjects;iObject++) {
          iColumn = originalObject[iObject]->columnNumber();
          if (iColumn<0) {
            nNonInt++;
          } else {
            temp[iColumn]=iObject;
          }
        }
        int numberNewIntegers=0;
        int numberOldIntegers=0;
        int numberOldOther=0;
        for (iColumn=0;iColumn<numberColumns;iColumn++) {
          int jColumn = originalColumns[iColumn];
          if (temp[jColumn]>=0) {
            int iObject= temp[jColumn];
            CbcSimpleInteger * obj =
              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
            if (obj) 
              numberOldIntegers++;
            else
              numberOldOther++;
          } else if (isInteger(iColumn)) {
            numberNewIntegers++;
          }
        }
        /*
          Allocate an array to hold the indices of the integer variables.
          Make a large enough array for all objects
        */
        numberObjects_= numberNewIntegers+numberOldIntegers+numberOldOther+nNonInt;
        object_ = new OsiObject * [numberObjects_];
        delete [] integerVariable_;
        integerVariable_ = new int [numberNewIntegers+numberOldIntegers];
        /*
          Walk the variables again, filling in the indices and creating objects for
          the integer variables. Initially, the objects hold the index and upper &
          lower bounds.
        */
        numberIntegers_=0;
        for (iColumn=0;iColumn<numberColumns;iColumn++) {
          int jColumn = originalColumns[iColumn];
          if (temp[jColumn]>=0) {
            int iObject= temp[jColumn];
            CbcSimpleInteger * obj =
              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
            if (obj) {
              object_[numberIntegers_] = originalObject[iObject]->clone();
              // redo ids etc
              object_[numberIntegers_]->resetSequenceEtc(numberColumns,originalColumns);
              integerVariable_[numberIntegers_++]=iColumn;
            }
          } else if (isInteger(iColumn)) {
            object_[numberIntegers_] =
              new CbcSimpleInteger(this,iColumn);
            integerVariable_[numberIntegers_++]=iColumn;
          }
        }
        numberObjects_=numberIntegers_;
        // Now append other column stuff
        for (iColumn=0;iColumn<numberColumns;iColumn++) {
          int jColumn = originalColumns[iColumn];
          if (temp[jColumn]>=0) {
            int iObject= temp[jColumn];
            CbcSimpleInteger * obj =
              dynamic_cast <CbcSimpleInteger *>(originalObject[iObject]) ;
            if (!obj) {
              object_[numberObjects_] = originalObject[iObject]->clone();
              // redo ids etc
              CbcObject * obj =
              dynamic_cast <CbcObject *>(object_[numberObjects_]) ;
              assert (obj);
              obj->redoSequenceEtc(this,numberColumns,originalColumns);
              numberObjects_++;
            }
          }
        }
        // now append non column stuff
        for (iObject=0;iObject<numberOriginalObjects;iObject++) {
          iColumn = originalObject[iObject]->columnNumber();
          if (iColumn<0) {
            object_[numberObjects_] = originalObject[iObject]->clone();
            // redo ids etc
            CbcObject * obj =
              dynamic_cast <CbcObject *>(object_[numberObjects_]) ;
            assert (obj);
            obj->redoSequenceEtc(this,numberColumns,originalColumns);
            numberObjects_++;
          }
        }
        delete [] temp;
        if (!numberObjects_)
          handler_->message(CBC_NOINT,messages_) << CoinMessageEol ;
      } else {
        int numberColumns = getNumCols();
        CglPreProcess * process = strategy_->process();
        assert (process);
        const int * originalColumns = process->originalColumns();
        // try and redo debugger
        OsiRowCutDebugger * debugger = const_cast<OsiRowCutDebugger *> (solver_->getRowCutDebuggerAlways());
        if (debugger)
          debugger->redoSolution(numberColumns,originalColumns);
      }
    } else {
      //no preprocessing
      originalSolver=NULL;
    }
    strategy_->setupCutGenerators(*this);
    strategy_->setupHeuristics(*this);
    // Set strategy print level to models
    strategy_->setupPrinting(*this,handler_->logLevel());
  }
  eventHappened_=false;
  CbcEventHandler *eventHandler = getEventHandler() ;
  if (eventHandler)
    eventHandler->setModel(this);
  // set up for probing
  probingInfo_ = new CglTreeProbingInfo(solver_);

  // Try for dominated columns
  if ((specialOptions_&64)!=0) {
    CglDuplicateRow dupcuts(solver_);
    dupcuts.setMode(2);
    CglStored * storedCuts = dupcuts.outDuplicates(solver_);
    addCutGenerator(storedCuts,1,"StoredCuts from dominated");
  }
  if (!nodeCompare_)
    nodeCompare_=new CbcCompareDefault();;
  // See if hot start wanted
  CbcCompareBase * saveCompare = NULL;
  if (hotstartSolution_) {
    if (strategy_&&strategy_->preProcessState()>0) {
      CglPreProcess * process = strategy_->process();
      assert (process);
      int n = solver_->getNumCols();
      const int * originalColumns = process->originalColumns();
      // columns should be in order ... but
      double * tempS = new double[n];
      for (int i=0;i<n;i++) {
        int iColumn = originalColumns[i];
        tempS[i]=hotstartSolution_[iColumn];
      }
      delete [] hotstartSolution_;
      hotstartSolution_=tempS;
      if (hotstartPriorities_) {
        int * tempP = new int [n];
        for (int i=0;i<n;i++) {
          int iColumn = originalColumns[i];
          tempP[i]=hotstartPriorities_[iColumn];
        }
        delete [] hotstartPriorities_;
        hotstartPriorities_=tempP;
      }
    }
    saveCompare = nodeCompare_;
    // depth first
    nodeCompare_ = new CbcCompareDepth();
  }
  if (!problemFeasibility_)
    problemFeasibility_=new CbcFeasibilityBase();
# ifdef CBC_DEBUG
  std::string problemName ;
  solver_->getStrParam(OsiProbName,problemName) ;
  printf("Problem name - %s\n",problemName.c_str()) ;
  solver_->setHintParam(OsiDoReducePrint,false,OsiHintDo,0) ;
# endif
/*
  Assume we're done, and see if we're proven wrong.
*/
  status_ = 0 ;
  secondaryStatus_ = 0;
  phase_=0;
/*
  Scan the variables, noting the integer variables. Create an
  CbcSimpleInteger object for each integer variable.
*/
  findIntegers(false) ;
  // If dynamic pseudo costs then do
  if (numberBeforeTrust_)
    convertToDynamic();
  // Set up char array to say if integer
  delete [] integerInfo_;
  {
    int n = solver_->getNumCols();
    integerInfo_ = new char [n];
    for (int i=0;i<n;i++) {
      if (solver_->isInteger(i))
        integerInfo_[i]=1;
      else
        integerInfo_[i]=0;
    }
  }
  if (preferredWay_) {
    // set all unset ones
    for (int iObject = 0 ; iObject < numberObjects_ ; iObject++) {
      CbcObject * obj =
        dynamic_cast <CbcObject *>(object_[iObject]) ;
      if (obj&&!obj->preferredWay())
        obj->setPreferredWay(preferredWay_);
    }
  }  
/*
  Ensure that objects on the lists of OsiObjects, heuristics, and cut
  generators attached to this model all refer to this model.
*/
  synchronizeModel() ;
  if (!solverCharacteristics_) {
    OsiBabSolver * solverCharacteristics = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
    if (solverCharacteristics) {
      solverCharacteristics_ = solverCharacteristics;
    } else {
      // replace in solver
      OsiBabSolver defaultC;
      solver_->setAuxiliaryInfo(&defaultC);
      solverCharacteristics_ = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
    }
  }
  solverCharacteristics_->setSolver(solver_);
  // Set so we can tell we are in initial phase in resolve
  continuousObjective_ = -COIN_DBL_MAX ;
/*
  Solve the relaxation.

  Apparently there are circumstances where this will be non-trivial --- i.e.,
  we've done something since initialSolve that's trashed the solution to the
  continuous relaxation.
*/
  bool feasible;
  // If NLP then we assume already solved outside branchAndbound
  if (!solverCharacteristics_->solverType()||solverCharacteristics_->solverType()==4) {
    feasible=resolve(NULL,0) != 0 ;
  } else {
    // pick up given status
    feasible = (solver_->isProvenOptimal() &&
                !solver_->isDualObjectiveLimitReached()) ;
  }
  if (problemFeasibility_->feasible(this,0)<0) {
    feasible=false; // pretend infeasible
  }
/*
  If the linear relaxation of the root is infeasible, bail out now. Otherwise,
  continue with processing the root node.
*/
  if (!feasible) {
    status_ = 0 ;
    if (!solver_->isProvenDualInfeasible()) {
      handler_->message(CBC_INFEAS,messages_)<< CoinMessageEol ;
      secondaryStatus_ = 1;
    } else {
      handler_->message(CBC_UNBOUNDED,messages_)<< CoinMessageEol ;
      secondaryStatus_ = 7;
    }
    originalContinuousObjective_ = COIN_DBL_MAX;
    solverCharacteristics_ = NULL;
    return ;
  }
  // Convert to Osi if wanted
  bool useOsiBranching=false;
  //OsiBranchingInformation * persistentInfo = NULL;
  if (branchingMethod_&&branchingMethod_->chooseMethod()) {
    useOsiBranching=true;
    //persistentInfo = new OsiBranchingInformation(solver_);
    if (numberOriginalObjects) {
      for (int iObject = 0 ; iObject < numberObjects_ ; iObject++) {
        CbcObject * obj =
          dynamic_cast <CbcObject *>(object_[iObject]) ;
        if (obj) {
          CbcSimpleInteger * obj2 =
            dynamic_cast <CbcSimpleInteger *>(obj) ;
          if (obj2) {
            // back to Osi land
            object_[iObject]=obj2->osiObject();
            delete obj;
          } else {
            OsiSimpleInteger * obj3 =
              dynamic_cast <OsiSimpleInteger *>(obj) ;
            if (!obj3) {
              OsiSOS * obj4 =
                dynamic_cast <OsiSOS *>(obj) ;
              if (!obj4) {
                CbcSOS * obj5 =
                  dynamic_cast <CbcSOS *>(obj) ;
                if (obj5) {
                  // back to Osi land
                  object_[iObject]=obj5->osiObject(solver_);
                } else {
                  printf("Code up CbcObject type in Osi land\n");
                  abort();
                }
              }
            }
          }
        }
      }
      // and add to solver
      solver_->addObjects(numberObjects_,object_);
    } else {
      // do from solver
      deleteObjects(false);
      solver_->findIntegersAndSOS(false);
      numberObjects_=solver_->numberObjects();
      object_ = solver_->objects();
      ownObjects_ = false;
    }
    branchingMethod_->chooseMethod()->setSolver(solver_);
  }
  // take off heuristics if have to
  if (numberHeuristics_) {
    int numberOdd=0;
    for (int i=0;i<numberObjects_;i++) {
      if (!object_[i]->canDoHeuristics()) 
        numberOdd++;
    }
    if (numberOdd) {
      int k=0;
      for (int i=0;i<numberHeuristics_;i++) {
        if (!heuristic_[i]->canDealWithOdd())
          delete heuristic_[i];
        else
          heuristic_[k++]=heuristic_[i];
      }
      if (!k) {
        delete [] heuristic_;
        heuristic_=NULL;
      }
      numberHeuristics_=k;
      handler_->message(CBC_HEURISTICS_OFF,messages_)<< numberOdd<<CoinMessageEol ;
    }
  }
  // Save objective (just so user can access it)
  originalContinuousObjective_ = solver_->getObjValue();
  bestPossibleObjective_=originalContinuousObjective_;
  sumChangeObjective1_=0.0;
  sumChangeObjective2_=0.0;
/*
  OsiRowCutDebugger knows an optimal answer for a subset of MIP problems.
  Assuming it recognises the problem, when called upon it will check a cut to
  see if it cuts off the optimal answer.
*/
  // If debugger exists set specialOptions_ bit
  if (solver_->getRowCutDebuggerAlways())
    specialOptions_ |= 1;

# ifdef CBC_DEBUG
  if ((specialOptions_&1)==0)
    solver_->activateRowCutDebugger(problemName.c_str()) ;
  if (solver_->getRowCutDebuggerAlways())
    specialOptions_ |= 1;
# endif

/*
  Begin setup to process a feasible root node.
*/
  bestObjective_ = CoinMin(bestObjective_,1.0e50) ;
  if (!bestSolution_) {
    numberSolutions_ = 0 ;
    numberHeuristicSolutions_ = 0 ;
  } 
  stateOfSearch_ = 0; 
  // Everything is minimization
  { 
    // needed to sync cutoffs
    double value ;
    solver_->getDblParam(OsiDualObjectiveLimit,value) ;
    dblParam_[CbcCurrentCutoff]= value * solver_->getObjSense();
  }
  double cutoff=getCutoff() ;
  double direction = solver_->getObjSense() ;
  dblParam_[CbcOptimizationDirection]=direction;
  if (cutoff < 1.0e20&&direction<0.0)
    messageHandler()->message(CBC_CUTOFF_WARNING1,
                                    messages())
                                      << cutoff << -cutoff << CoinMessageEol ;
  if (cutoff > bestObjective_)
    cutoff = bestObjective_ ;
  setCutoff(cutoff) ;
/*
  We probably already have a current solution, but just in case ...
*/
  int numberColumns = getNumCols() ;
  if (!currentSolution_)
    currentSolution_ = new double[numberColumns] ;
  testSolution_ = currentSolution_;
  /* Tell solver we are in Branch and Cut
     Could use last parameter for subtle differences */
  solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
#ifdef COIN_HAS_CLP
 {
   OsiClpSolverInterface * clpSolver 
     = dynamic_cast<OsiClpSolverInterface *> (solver_);
   if (clpSolver) {
     //#define CLP_QUICK_OPTIONS
#ifdef CLP_QUICK_OPTIONS
     // Try and re-use regions   
     ClpSimplex * simplex = clpSolver->getModelPtr();
     simplex->setPersistenceFlag(1);
     clpSolver->deleteScaleFactors();
     int value=131072;
     clpSolver->setSpecialOptions(clpSolver->specialOptions()|value);
     if ((clpSolver->specialOptions()&value)!=0)
       simplex->setSpecialOptions(simplex->specialOptions()|value);
     //if (simplex->numberRows()<50)
     //simplex->setAlphaAccuracy(1.0);
     //clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
#endif
     if ((specialOptions_&32)==0) {
       ClpSimplex * clpSimplex = clpSolver->getModelPtr();
       // take off names
       clpSimplex->dropNames();
     }
     // no crunch if mostly continuous
     int numberColumns = solver_->getNumCols();
     if (numberColumns>1000&&numberIntegers_*4<numberColumns)
       clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
   }
 }
#endif
/*
  Create a copy of the solver, thus capturing the original (root node)
  constraint system (aka the continuous system).
*/
  continuousSolver_ = solver_->clone() ;

  numberRowsAtContinuous_ = getNumRows() ;
/*
  Check the objective to see if we can deduce a nontrivial increment. If
  it's better than the current value for CbcCutoffIncrement, it'll be
  installed.
*/
  if(solverCharacteristics_->reducedCostsAccurate())
    analyzeObjective() ;
/*
  Set up for cut generation. addedCuts_ holds the cuts which are relevant for
  the active subproblem. whichGenerator will be used to record the generator
  that produced a given cut.
*/
  maximumWhich_ = 1000 ;
  delete [] whichGenerator_;
  whichGenerator_ = new int[maximumWhich_] ;
  memset(whichGenerator_,0,maximumWhich_*sizeof(int));
  maximumNumberCuts_ = 0 ;
  currentNumberCuts_ = 0 ;
  delete [] addedCuts_ ;
  addedCuts_ = NULL ;
/*
  Set up an empty heap and associated data structures to hold the live set
  (problems which require further exploration).
*/
  tree_->setComparison(*nodeCompare_) ;
/*
  Used to record the path from a node to the root of the search tree, so that
  we can then traverse from the root to the node when restoring a subproblem.
*/
  maximumDepth_ = 10 ;
  delete [] walkback_ ;
  walkback_ = new CbcNodeInfo * [maximumDepth_] ;
/*
  Used to generate bound edits for CbcPartialNodeInfo.
*/
  double * lowerBefore = new double [numberColumns] ;
  double * upperBefore = new double [numberColumns] ;
/*
  
  Generate cuts at the root node and reoptimise. solveWithCuts does the heavy
  lifting. It will iterate a generate/reoptimise loop (including reduced cost
  fixing) until no cuts are generated, the change in objective falls off,  or
  the limit on the number of rounds of cut generation is exceeded.

  At the end of all this, any cuts will be recorded in cuts and also
  installed in the solver's constraint system. We'll have reoptimised, and
  removed any slack cuts (numberOldActiveCuts_ and numberNewCuts_ have been
  adjusted accordingly).

  Tell cut generators they can be a bit more aggressive at root node

  TODO: Why don't we make a copy of the solution after solveWithCuts?
  TODO: If numberUnsatisfied == 0, don't we have a solution?
*/
  phase_=1;
  int iCutGenerator;
  for (iCutGenerator = 0;iCutGenerator<numberCutGenerators_;iCutGenerator++) {
    CglCutGenerator * generator = generator_[iCutGenerator]->generator();
    generator->setAggressiveness(generator->getAggressiveness()+100);
  }
  OsiCuts cuts ;
  int anyAction = -1 ;
  numberOldActiveCuts_ = 0 ;
  numberNewCuts_ = 0 ;
  // Array to mark solution
  delete [] usedInSolution_;
  usedInSolution_ = new int[numberColumns];
  CoinZeroN(usedInSolution_,numberColumns);
/*
  For printing totals and for CbcNode (numberNodes_)
*/
  numberIterations_ = 0 ;
  numberNodes_ = 0 ;
  numberNodes2_ = 0 ;
  maximumStatistics_=0;
  maximumDepthActual_=0;
  numberDJFixed_=0.0;
  // Do heuristics
  doHeuristicsAtRoot();
  if ( intParam_[CbcMaxNumNode] < 0)
    eventHappened_=true; // stop as fast as possible
  statistics_ = NULL;
  // Do on switch
  if (doStatistics>0&&doStatistics<100) {
    maximumStatistics_=10000;
    statistics_ = new CbcStatistics * [maximumStatistics_];
    memset(statistics_,0,maximumStatistics_*sizeof(CbcStatistics *));
  }

  { int iObject ;
    int preferredWay ;
    int numberUnsatisfied = 0 ;
    memcpy(currentSolution_,solver_->getColSolution(),
           numberColumns*sizeof(double)) ;
    // point to useful information
    OsiBranchingInformation usefulInfo=usefulInformation();

    for (iObject = 0 ; iObject < numberObjects_ ; iObject++)
    { double infeasibility =
          object_[iObject]->infeasibility(&usefulInfo,preferredWay) ;
      if (infeasibility ) numberUnsatisfied++ ; }
    // replace solverType 
    if(solverCharacteristics_->tryCuts())  {

      if (numberUnsatisfied)   {
        // User event
        if (!eventHappened_)
          feasible = solveWithCuts(cuts,maximumCutPassesAtRoot_,
                                   NULL);
        else
          feasible=false;
      } else if (solverCharacteristics_->solutionAddsCuts()||
                 solverCharacteristics_->alwaysTryCutsAtRootNode()) {
        // may generate cuts and turn the solution
        //to an infeasible one
        feasible = solveWithCuts(cuts, 1,
                                 NULL);
      }
    }
    // check extra info on feasibility
    if (!solverCharacteristics_->mipFeasible())
      feasible = false;
  }
  // make cut generators less aggressive
  for (iCutGenerator = 0;iCutGenerator<numberCutGenerators_;iCutGenerator++) {
    CglCutGenerator * generator = generator_[iCutGenerator]->generator();
    generator->setAggressiveness(generator->getAggressiveness()-100);
  }
  currentNumberCuts_ = numberNewCuts_ ;
  // See if can stop on gap
  stoppedOnGap_ = false ;
  bestPossibleObjective_ = solver_->getObjValue()*solver_->getObjSense();
  double testGap = CoinMax(dblParam_[CbcAllowableGap],
                           CoinMax(fabs(bestObjective_),fabs(bestPossibleObjective_))
                           *dblParam_[CbcAllowableFractionGap]);
  if (bestObjective_-bestPossibleObjective_ < testGap && getCutoffIncrement()>=0.0) {
    if (bestPossibleObjective_<getCutoff())
      stoppedOnGap_ = true ;
    feasible = false;
  }
  // User event
  if (eventHappened_)
    feasible=false;
/*
  We've taken the continuous relaxation as far as we can. Time to branch.
  The first order of business is to actually create a node. chooseBranch
  currently uses strong branching to evaluate branch object candidates,
  unless forced back to simple branching. If chooseBranch concludes that a
  branching candidate is monotone (anyAction == -1) or infeasible (anyAction
  == -2) when forced to integer values, it returns here immediately.

  Monotone variables trigger a call to resolve(). If the problem remains
  feasible, try again to choose a branching variable. At the end of the loop,
  resolved == true indicates that some variables were fixed.

  Loss of feasibility will result in the deletion of newNode.
*/

  bool resolved = false ;
  CbcNode *newNode = NULL ;
  numberFixedAtRoot_=0;
  numberFixedNow_=0;
  int numberIterationsAtContinuous = numberIterations_;
  //solverCharacteristics_->setSolver(solver_);
  if (feasible) {
    newNode = new CbcNode ;
    // Set objective value (not so obvious if NLP etc)
    setObjectiveValue(newNode,NULL);
    anyAction = -1 ;
    // To make depth available we may need a fake node
    CbcNode fakeNode;
    if (!currentNode_) {
      // Not true if sub trees assert (!numberNodes_);
      currentNode_=&fakeNode;
    }
    phase_=3;
    // only allow 1000 passes
    int numberPassesLeft=1000;
    // This is first crude step
    if (numberAnalyzeIterations_) {
      delete [] analyzeResults_;
      analyzeResults_ = new double [4*numberIntegers_];
      numberFixedAtRoot_=newNode->analyze(this,analyzeResults_);
      if (numberFixedAtRoot_>0) {
        printf("%d fixed by analysis\n",numberFixedAtRoot_);
        setPointers(solver_);
        numberFixedNow_ = numberFixedAtRoot_;
      } else if (numberFixedAtRoot_<0) {
        printf("analysis found to be infeasible\n");
        anyAction=-2;
        delete newNode ;
        newNode = NULL ;
        feasible = false ;
      }
    }
    OsiSolverBranch * branches = NULL;
    anyAction = chooseBranch(newNode, numberPassesLeft, NULL, cuts,resolved,
                             NULL,NULL,NULL,branches);
    if (anyAction == -2||newNode->objectiveValue() >= cutoff) {
      if (anyAction != -2) {
        // zap parent nodeInfo
#ifdef COIN_DEVELOP
        printf("zapping CbcNodeInfo %x\n",newNode->nodeInfo()->parent());
#endif
        if (newNode->nodeInfo())
          newNode->nodeInfo()->nullParent();
      }
      delete newNode ;
      newNode = NULL ;
      feasible = false ;
    }
  }
/*
  At this point, the root subproblem is infeasible or fathomed by bound
  (newNode == NULL), or we're live with an objective value that satisfies the
  current objective cutoff.
*/
  assert (!newNode || newNode->objectiveValue() <= cutoff) ;
  // Save address of root node as we don't want to delete it
  // initialize for print out
  int lastDepth=0;
  int lastUnsatisfied=0;
  if (newNode)
    lastUnsatisfied=newNode->numberUnsatisfied();
/*
  The common case is that the lp relaxation is feasible but doesn't satisfy
  integrality (i.e., newNode->branchingObject(), indicating we've been able to
  select a branching variable). Remove any cuts that have gone slack due to
  forcing monotone variables. Then tack on an CbcFullNodeInfo object and full
  basis (via createInfo()) and stash the new cuts in the nodeInfo (via
  addCuts()). If, by some miracle, we have an integral solution at the root
  (newNode->branchingObject() is NULL), takeOffCuts() will ensure that the solver holds
  a valid solution for use by setBestSolution().
*/
  CoinWarmStartBasis *lastws = NULL ;
  if (feasible && newNode->branchingObject())
  { if (resolved)
    { takeOffCuts(cuts,false,NULL) ;
#     ifdef CHECK_CUT_COUNTS
      { printf("Number of rows after chooseBranch fix (root)"
               "(active only) %d\n",
                numberRowsAtContinuous_+numberNewCuts_+numberOldActiveCuts_) ;
        const CoinWarmStartBasis* debugws =
          dynamic_cast <const CoinWarmStartBasis*>(solver_->getWarmStart()) ;
        debugws->print() ;
        delete debugws ; }
#     endif
    }
  //newNode->createInfo(this,NULL,NULL,NULL,NULL,0,0) ;
    newNode->nodeInfo()->addCuts(cuts,
                                 newNode->numberBranches(),whichGenerator_) ;
    if (lastws) delete lastws ;
    lastws = dynamic_cast<CoinWarmStartBasis*>(solver_->getWarmStart()) ;
  }
/*
  Continuous data to be used later
*/
  continuousObjective_ = solver_->getObjValue()*solver_->getObjSense();
  continuousInfeasibilities_ = 0 ;
  if (newNode)
  { continuousObjective_ = newNode->objectiveValue() ;
    delete [] continuousSolution_;
    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),
                                             numberColumns);
    continuousInfeasibilities_ = newNode->numberUnsatisfied() ; }
/*
  Bound may have changed so reset in objects
*/
  { int i ;
    for (i = 0;i < numberObjects_;i++)
      object_[i]->resetBounds(solver_) ; }
/*
  Feasible? Then we should have either a live node prepped for future
  expansion (indicated by variable() >= 0), or (miracle of miracles) an
  integral solution at the root node.

  initializeInfo sets the reference counts in the nodeInfo object.  Since
  this node is still live, push it onto the heap that holds the live set.
*/
  double bestValue = 0.0 ;
  if (newNode) {
    bestValue = newNode->objectiveValue();
    if (newNode->branchingObject()) {
      newNode->initializeInfo() ;
      tree_->push(newNode) ;
      if (statistics_) {
        if (numberNodes2_==maximumStatistics_) {
          maximumStatistics_ = 2*maximumStatistics_;
          CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
          memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
          memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
          delete [] statistics_;
          statistics_=temp;
        }
        assert (!statistics_[numberNodes2_]);
        statistics_[numberNodes2_]=new CbcStatistics(newNode);
      }
      numberNodes2_++;
#     ifdef CHECK_NODE
      printf("Node %x on tree\n",newNode) ;
#     endif
    } else {
      // continuous is integer
      double objectiveValue = newNode->objectiveValue();
      setBestSolution(CBC_SOLUTION,objectiveValue,
                      solver_->getColSolution()) ;
      delete newNode ;
      newNode = NULL ;
    }
  }

  if (printFrequency_ <= 0) {
    printFrequency_ = 1000 ;
    if (getNumCols() > 2000)
      printFrequency_ = 100 ;
  }
  /*
    It is possible that strong branching fixes one variable and then the code goes round
    again and again.  This can take too long.  So we need to warn user - just once.
  */
  numberLongStrong_=0;
  double totalTime = 0.0;
#ifdef CBC_THREAD
  CbcNode * createdNode=NULL;
  CbcModel ** threadModel = NULL;
  pthread_t * threadId = NULL;
  int * threadCount = NULL;
  pthread_mutex_t mutex;
  pthread_cond_t condition_main;
  pthread_mutex_t condition_mutex;
  pthread_mutex_t * mutex2 = NULL;
  pthread_cond_t * condition2 = NULL;
  threadStruct * threadInfo = NULL;
  bool locked=false;
  int threadStats[6];
  memset(threadStats,0,sizeof(threadStats));
  double timeWaiting=0.0;
  // For now just one model
  if (numberThreads_) {
    threadId = new pthread_t [numberThreads_];
    threadCount = new int [numberThreads_];
    CoinZeroN(threadCount,numberThreads_);
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&condition_main,NULL);
    pthread_mutex_init(&condition_mutex,NULL);
    threadModel = new CbcModel * [numberThreads_+1];
    threadInfo = new threadStruct [numberThreads_+1];
    mutex2 = new pthread_mutex_t [numberThreads_];
    condition2 = new pthread_cond_t [numberThreads_];
    // we don't want a strategy object
    CbcStrategy * saveStrategy = strategy_;
    strategy_ = NULL;
    for (int i=0;i<numberThreads_;i++) {
      pthread_mutex_init(mutex2+i,NULL);
      pthread_cond_init(condition2+i,NULL);
      threadId[i]=0;
      threadInfo[i].baseModel=this;
      threadModel[i]=new CbcModel(*this);
#ifdef COIN_HAS_CLP
      // Solver may need to know about model
      CbcModel * thisModel = threadModel[i];
      CbcOsiSolver * solver =
              dynamic_cast<CbcOsiSolver *>(thisModel->solver()) ;
      if (solver)
        solver->setCbcModel(thisModel);
#endif
      mutex_ = (void *) (threadInfo+i);
      threadModel[i]->moveToModel(this,-1);
      threadInfo[i].thisModel=threadModel[i];
      threadInfo[i].node=NULL;
      threadInfo[i].createdNode=NULL;
      threadInfo[i].threadIdOfBase=pthread_self();
      threadInfo[i].mutex=&mutex;
      threadInfo[i].mutex2=mutex2+i;
      threadInfo[i].condition2=condition2+i;
      threadInfo[i].returnCode=-1;
      threadInfo[i].timeLocked=0.0;
      threadInfo[i].timeWaitingToLock=0.0;
      threadInfo[i].timeWaitingToStart=0.0;
      threadInfo[i].timeInThread=0.0;
      threadInfo[i].numberTimesLocked=0;
      threadInfo[i].numberTimesUnlocked=0;
      threadInfo[i].numberTimesWaitingToStart=0;
      threadInfo[i].locked=false;
#if CBC_THREAD_DEBUG
      threadInfo[i].threadNumber=i+2;
#endif
      pthread_create(threadId+i,NULL,doNodesThread,threadInfo+i);
    }
    strategy_ = saveStrategy;
    // Do a partial one for base model
    threadInfo[numberThreads_].baseModel=this;
    threadModel[numberThreads_]=this;
    mutex_ = (void *) (threadInfo+numberThreads_);
    threadInfo[numberThreads_].node=NULL;
    threadInfo[numberThreads_].mutex=&mutex;
    threadInfo[numberThreads_].condition2=&condition_main;
    threadInfo[numberThreads_].mutex2=&condition_mutex;
    threadInfo[numberThreads_].timeLocked=0.0;
    threadInfo[numberThreads_].timeWaitingToLock=0.0;
    threadInfo[numberThreads_].numberTimesLocked=0;
    threadInfo[numberThreads_].numberTimesUnlocked=0;
    threadInfo[numberThreads_].locked=false;
#if CBC_THREAD_DEBUG
    threadInfo[numberThreads_].threadNumber=1;
#endif
  }
#endif
/*
  At last, the actual branch-and-cut search loop, which will iterate until
  the live set is empty or we hit some limit (integrality gap, time, node
  count, etc.). The overall flow is to rebuild a subproblem, reoptimise using
  solveWithCuts(), choose a branching pattern with chooseBranch(), and finally
  add the node to the live set.

  The first action is to winnow the live set to remove nodes which are worse
  than the current objective cutoff.
*/
  if (solver_->getRowCutDebuggerAlways()) {
    OsiRowCutDebugger * debuggerX = const_cast<OsiRowCutDebugger *> (solver_->getRowCutDebuggerAlways());
    const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
    if (!debugger) {
      // infeasible!!
      printf("before search\n");
      const double * lower = solver_->getColLower();
      const double * upper = solver_->getColUpper();
      const double * solution = debuggerX->optimalSolution();
      int numberColumns = solver_->getNumCols();
      for (int i=0;i<numberColumns;i++) {
        if (solver_->isInteger(i)) {
          if (solution[i]<lower[i]-1.0e-6||solution[i]>upper[i]+1.0e-6)
            printf("**** ");
          printf("%d %g <= %g <= %g\n",
                 i,lower[i],solution[i],upper[i]);
        }
      }
      //abort();
    }
  }
  while (true) {
#ifdef CBC_THREAD
    if (!locked) {
      lockThread();
      locked=true;
    }
#endif
    if (tree_->empty()) {
#ifdef CBC_THREAD
      if (numberThreads_) {
#ifdef COIN_DEVELOP
        printf("empty\n");
#endif
        // may still be outstanding nodes
        int iThread;
        for (iThread=0;iThread<numberThreads_;iThread++) {
          if (threadId[iThread]) {
            if (threadInfo[iThread].returnCode==0) 
              break;
          }
        }
        if (iThread<numberThreads_) {
#ifdef COIN_DEVELOP
          printf("waiting for thread %d code 0\n",iThread);
#endif
          unlockThread();
          locked = false;
          pthread_cond_signal(threadInfo[iThread].condition2); // unlock in case
          while (true) {
            pthread_mutex_lock(&condition_mutex);
            struct timespec absTime;
            clock_gettime(CLOCK_REALTIME,&absTime);
            double time = absTime.tv_sec+1.0e-9*absTime.tv_nsec;
            absTime.tv_nsec += 1000000; // millisecond
            if (absTime.tv_nsec>=1000000000) {
              absTime.tv_nsec -= 1000000000;
              absTime.tv_sec++;
            }
            pthread_cond_timedwait(&condition_main,&condition_mutex,&absTime);
            clock_gettime(CLOCK_REALTIME,&absTime);
            double time2 = absTime.tv_sec+1.0e-9*absTime.tv_nsec;
            timeWaiting += time2-time;
            pthread_mutex_unlock(&condition_mutex);
            if (threadInfo[iThread].returnCode!=0) 
              break;
            pthread_cond_signal(threadInfo[iThread].condition2); // unlock
          }
          threadModel[iThread]->moveToModel(this,1);
          assert (threadInfo[iThread].returnCode==1);
          // say available
          threadInfo[iThread].returnCode=-1;
          threadStats[4]++;
#ifdef COIN_DEVELOP
          printf("thread %d code now -1\n",iThread);
#endif
          continue;
        } else {
#ifdef COIN_DEVELOP
          printf("no threads at code 0 \n");
#endif
          // now check if any have just finished
          for (iThread=0;iThread<numberThreads_;iThread++) {
            if (threadId[iThread]) {
              if (threadInfo[iThread].returnCode==1) 
                break;
            }
          }
          if (iThread<numberThreads_) {
            unlockThread();
            locked = false;
            threadModel[iThread]->moveToModel(this,1);
            assert (threadInfo[iThread].returnCode==1);
            // say available
            threadInfo[iThread].returnCode=-1;
            threadStats[4]++;
#ifdef COIN_DEVELOP
            printf("thread %d code now -1\n",iThread);
#endif
            continue;
          }
        }
        if (!tree_->empty()) {
#ifdef COIN_DEVELOP
          printf("tree not empty!!!!!!\n");
#endif
          continue;
        }
        for (iThread=0;iThread<numberThreads_;iThread++) {
          if (threadId[iThread]) {
            if (threadInfo[iThread].returnCode!=-1) { 
              printf("bad end of tree\n");
              abort();
            }
          }
        }
#ifdef COIN_DEVELOP
        printf("finished ************\n");
#endif
      }
      unlockThread();
      locked=false; // not needed as break
#endif
      break;
    }
#ifdef CBC_THREAD
    unlockThread();
    locked = false;
#endif
/*
  Check for abort on limits: node count, solution count, time, integrality gap.
*/
    totalTime = getCurrentSeconds() ;
    double maxSeconds = getMaximumSeconds();
    if (parentModel_)
      maxSeconds=CoinMin(maxSeconds,parentModel_->getMaximumSeconds());
    if (!(numberNodes_ < intParam_[CbcMaxNumNode] &&
          numberSolutions_ < intParam_[CbcMaxNumSol] &&
          totalTime < maxSeconds &&
          !stoppedOnGap_&&!eventHappened_)) {
      // out of loop
      break;
    }
#ifdef BONMIN
    assert(!solverCharacteristics_->solutionAddsCuts() || solverCharacteristics_->mipFeasible());
#endif
    if (cutoff > getCutoff()) {
      double newCutoff = getCutoff();
      if (analyzeResults_) {
        // see if we could fix any (more)
        int n=0;
        double * newLower = analyzeResults_;
        double * objLower = newLower+numberIntegers_;
        double * newUpper = objLower+numberIntegers_;
        double * objUpper = newUpper+numberIntegers_;
        for (int i=0;i<numberIntegers_;i++) {
          if (objLower[i]>newCutoff) {
            n++;
            if (objUpper[i]>newCutoff) {
              newCutoff = -COIN_DBL_MAX;
              break;
            }
          } else if (objUpper[i]>newCutoff) {
            n++;
          }
        }
        if (newCutoff==-COIN_DBL_MAX) {
          printf("Root analysis says finished\n");
        } else if (n>numberFixedNow_) {
          printf("%d more fixed by analysis - now %d\n",n-numberFixedNow_,n);
          numberFixedNow_=n;
        }
      }
      if (eventHandler) {
        if (!eventHandler->event(CbcEventHandler::solution)) {
          eventHappened_=true; // exit
        }
      }
      lockThread();
      // Do from deepest
      tree_->cleanTree(this, newCutoff,bestPossibleObjective_) ;
      nodeCompare_->newSolution(this) ;
      nodeCompare_->newSolution(this,continuousObjective_,
                                continuousInfeasibilities_) ;
      tree_->setComparison(*nodeCompare_) ;
      if (tree_->empty()) {
        unlockThread();
        // For threads we need to check further
        //break; // finished
        continue;
      }
      unlockThread();
    }
    cutoff = getCutoff() ;
/*
    Periodic activities: Opportunities to
    + tweak the nodeCompare criteria,
    + check if we've closed the integrality gap enough to quit, 
    + print a summary line to let the user know we're working
*/
    if ((numberNodes_%1000) == 0) {
      lockThread();
      bool redoTree=nodeCompare_->every1000Nodes(this, numberNodes_) ;
#ifdef CHECK_CUT_SIZE
      verifyCutSize (tree_, *this);
#endif
      // redo tree if wanted
      if (redoTree)
        tree_->setComparison(*nodeCompare_) ;
      unlockThread();
    }
    if (saveCompare&&!hotstartSolution_) {
      // hotstart switched off
      delete nodeCompare_; // off depth first
      nodeCompare_=saveCompare;
      saveCompare=NULL;
      // redo tree
      lockThread();
      tree_->setComparison(*nodeCompare_) ;
      unlockThread();
    }
    if ((numberNodes_%printFrequency_) == 0) {
      lockThread();
      int nNodes = tree_->size() ;

      //MODIF PIERRE
      bestPossibleObjective_ = tree_->getBestPossibleObjective();
      unlockThread();
      if (!intParam_[CbcPrinting]) {
        messageHandler()->message(CBC_STATUS,messages())
          << numberNodes_<< nNodes<< bestObjective_<< bestPossibleObjective_
          <<getCurrentSeconds()
          << CoinMessageEol ;
      } else {
        messageHandler()->message(CBC_STATUS2,messages())
          << numberNodes_<< nNodes<< bestObjective_<< bestPossibleObjective_
          <<lastDepth<<lastUnsatisfied<<numberIterations_
          <<getCurrentSeconds()
          << CoinMessageEol ;
      }
      if (!eventHandler->event(CbcEventHandler::treeStatus)) {
        eventHappened_=true; // exit
      }
    }
    // If no solution but many nodes - signal change in strategy
    if (numberNodes_>2*numberObjects_+1000&&stateOfSearch_!=2)
      stateOfSearch_=3;
    // See if can stop on gap
    double testGap = CoinMax(dblParam_[CbcAllowableGap],
                             CoinMax(fabs(bestObjective_),fabs(bestPossibleObjective_))
                             *dblParam_[CbcAllowableFractionGap]);
    if (bestObjective_-bestPossibleObjective_ < testGap && getCutoffIncrement()>=0.0) {
      stoppedOnGap_ = true ;
    }
    
#   ifdef CHECK_NODE_FULL
    verifyTreeNodes(tree_,*this) ;
#   endif
#   ifdef CHECK_CUT_COUNTS
    verifyCutCounts(tree_,*this) ;
#   endif
/*
  Now we come to the meat of the loop. To create the active subproblem, we'll
  pop the most promising node in the live set, rebuild the subproblem it
  represents, and then execute the current arm of the branch to create the
  active subproblem.
*/
    CbcNode *node = tree_->bestNode(cutoff) ;
    // Possible one on tree worse than cutoff
    if (!node)
      continue;
#ifndef CBC_THREAD
    int currentNumberCuts = 0 ;
    currentNode_=node; // so can be accessed elsewhere
#ifdef CBC_DEBUG
    printf("%d unsat, way %d, obj %g est %g\n",
           node->numberUnsatisfied(),node->way(),node->objectiveValue(),
           node->guessedObjectiveValue());
#endif
#if NEW_UPDATE_OBJECT==0
    // Save clone in branching decision
    if(branchingMethod_)
      branchingMethod_->saveBranchingObject(node->modifiableBranchingObject());
#endif
    // Say not on optimal path
    bool onOptimalPath=false;
#   ifdef CHECK_NODE
    printf("Node %x popped from tree - %d left, %d count\n",node,
           node->nodeInfo()->numberBranchesLeft(),
           node->nodeInfo()->numberPointingToThis()) ;
    printf("\tdepth = %d, z =  %g, unsat = %d, var = %d.\n",
           node->depth(),node->objectiveValue(),
           node->numberUnsatisfied(),
           node->columnNumber()) ;
#   endif
    lastDepth=node->depth();
    lastUnsatisfied=node->numberUnsatisfied();

/*
  Rebuild the subproblem for this node:  Call addCuts() to adjust the model
  to recreate the subproblem for this node (set proper variable bounds, add
  cuts, create a basis).  This may result in the problem being fathomed by
  bound or infeasibility. Returns 1 if node is fathomed.
  Execute the current arm of the branch: If the problem survives, save the
  resulting variable bounds and call branch() to modify variable bounds
  according to the current arm of the branching object. If we're processing
  the final arm of the branching object, flag the node for removal from the
  live set.
*/
    CbcNodeInfo * nodeInfo = node->nodeInfo() ;
    newNode = NULL ;
    int branchesLeft=0;
    if (!addCuts(node,lastws,numberFixedNow_>numberFixedAtRoot_))
    { int i ;
      const double * lower = getColLower() ;
      const double * upper = getColUpper() ;
      for (i = 0 ; i < numberColumns ; i++)
      { lowerBefore[i]= lower[i] ;
        upperBefore[i]= upper[i] ; }
      if ((solverCharacteristics_->extraCharacteristics()&2)!=0) {
        solverCharacteristics_->setBeforeLower(lowerBefore);
        solverCharacteristics_->setBeforeUpper(upperBefore);
      }
      if (messageHandler()->logLevel()>2)
        node->modifiableBranchingObject()->print();
      if (!useOsiBranching) 
        branchesLeft = node->branch(NULL); // old way
      else
        branchesLeft = node->branch(solver_); // new way
      if (branchesLeft) {
        // set nodenumber correctly
        node->nodeInfo()->setNodeNumber(numberNodes2_);
        tree_->push(node) ;
        if (statistics_) {
          if (numberNodes2_==maximumStatistics_) {
            maximumStatistics_ = 2*maximumStatistics_;
            CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
            memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
            memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
            delete [] statistics_;
            statistics_=temp;
          }
          assert (!statistics_[numberNodes2_]);
          statistics_[numberNodes2_]=new CbcStatistics(node);
        }
        numberNodes2_++;
        //nodeOnTree=true; // back on tree
        //deleteNode = false ;
#       ifdef CHECK_NODE
        printf("Node %x pushed back on tree - %d left, %d count\n",node,
               nodeInfo->numberBranchesLeft(),
               nodeInfo->numberPointingToThis()) ;
#       endif
      } else {
        //deleteNode = true ;
        if (!nodeInfo->numberBranchesLeft())
          nodeInfo->allBranchesGone(); // can clean up
      }
      if ((specialOptions_&1)!=0) {
        /*
          This doesn't work as intended --- getRowCutDebugger will return null
          unless the current feasible solution region includes the optimal solution
          that RowCutDebugger knows. There's no way to tell inactive from off the
          optimal path.
        */
        const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
        if (debugger) {
          onOptimalPath=true;
          printf("On optimal path\n") ;
        }
      }
      
/*
  Reoptimize, possibly generating cuts and/or using heuristics to find
  solutions.  Cut reference counts are unaffected unless we lose feasibility,
  in which case solveWithCuts() will make the adjustment.
*/
      phase_=2;
      cuts = OsiCuts() ;
      currentNumberCuts = solver_->getNumRows()-numberRowsAtContinuous_ ;
      int saveNumber = numberIterations_;
      if(solverCharacteristics_->solutionAddsCuts()) {
        int returnCode=resolve(node ? node->nodeInfo() : NULL,1);
        feasible = returnCode != 0;
        if (feasible) {
          int iObject ;
          int preferredWay ;
          int numberUnsatisfied = 0 ;
          memcpy(currentSolution_,solver_->getColSolution(),
                 numberColumns*sizeof(double)) ;
          // point to useful information
          OsiBranchingInformation usefulInfo=usefulInformation();
          
          for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
            double infeasibility =
              object_[iObject]->infeasibility(&usefulInfo,preferredWay) ;
            if (infeasibility ) numberUnsatisfied++ ;
          }
          if (returnCode>0) {
            if (numberUnsatisfied)   {
              feasible = solveWithCuts(cuts,maximumCutPasses_,node);
            } else {
              // may generate cuts and turn the solution
              //to an infeasible one
              feasible = solveWithCuts(cuts, 1,
                                       node);
#if 0
              currentNumberCuts_ = cuts.sizeRowCuts();
              if (currentNumberCuts_ >= maximumNumberCuts_) {
                maximumNumberCuts_ = currentNumberCuts;
                delete [] addedCuts_;
                addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
              }
#endif
            }
          }
          // check extra info on feasibility
          if (!solverCharacteristics_->mipFeasible()) {
            feasible = false;
            solverCharacteristics_->setMipBound(-COIN_DBL_MAX);
          }
        }
      } else {
        // normal
        //int zzzzzz=0;
        //if (zzzzzz)
        //solver_->writeMps("before");
        feasible = solveWithCuts(cuts,maximumCutPasses_,node);
      }
      if ((specialOptions_&1)!=0&&onOptimalPath) {
        if (!solver_->getRowCutDebugger()) {
          // dj fix did something???
          solver_->writeMps("infeas2");
          assert (solver_->getRowCutDebugger()) ;
        }
      }
      if (statistics_) {
        assert (numberNodes2_);
        assert (statistics_[numberNodes2_-1]);
        assert (statistics_[numberNodes2_-1]->node()==numberNodes2_-1);
        statistics_[numberNodes2_-1]->endOfBranch(numberIterations_-saveNumber,
                                               feasible ? solver_->getObjValue()
                                               : COIN_DBL_MAX);
      }
/*
  Are we still feasible? If so, create a node and do the work to attach a
  branching object, reoptimising as needed if chooseBranch() identifies
  monotone objects.

  Finally, attach a partial nodeInfo object and store away any cuts that we
  created back in solveWithCuts. addCuts() will initialise the reference
  counts for these new cuts.

  This next test can be problematic if we've discovered an
  alternate equivalent answer and subsequently fathom the solution
  known to the row cut debugger due to bounds.
*/
        if (onOptimalPath) {
          bool objLim = solver_->isDualObjectiveLimitReached() ;
          if (!feasible && !objLim) {
            printf("infeas2\n");
            solver_->writeMps("infeas");
            CoinWarmStartBasis *slack =
              dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart()) ;
            solver_->setWarmStart(slack);
            delete slack ;
            solver_->setHintParam(OsiDoReducePrint,false,OsiHintDo,0) ;
            solver_->initialSolve();
            assert (!solver_->isProvenOptimal());
          }
          assert (feasible || objLim);
        }
        bool checkingNode=false;
        if (feasible) {
          newNode = new CbcNode ;//Regular node of the tree
          // Set objective value (not so obvious if NLP etc)
          setObjectiveValue(newNode,node);
          anyAction =-1 ;
          resolved = false ;
          if (newNode->objectiveValue() >= getCutoff()) 
            anyAction=-2;
          // only allow at most a few passes
          int numberPassesLeft=5;
          checkingNode=true;
        OsiSolverBranch * branches=NULL;
        // point to useful information
        anyAction = chooseBranch(newNode, numberPassesLeft,node, cuts,resolved,
                                 lastws, lowerBefore, upperBefore, branches);
/*
  If we end up infeasible, we can delete the new node immediately. Since this
  node won't be needing the cuts we collected, decrement the reference counts.
  If we are feasible, then we'll be placing this node into the live set, so
  increment the reference count in the current (parent) nodeInfo.
*/
        if (anyAction == -2)
          { delete newNode ;
          newNode = NULL ;
          // say strong doing well
          if (checkingNode)
            setSpecialOptions(specialOptions_|8);
          for (i = 0 ; i < currentNumberCuts_ ; i++)
            { if (addedCuts_[i])
              { if (!addedCuts_[i]->decrement(1))
                delete addedCuts_[i] ; } } }
        else
          { nodeInfo->increment() ;
          if ((numberNodes_%20)==0) {
            // say strong not doing as well
            setSpecialOptions(specialOptions_&~8);
          }
        }
        }
/*
  At this point, there are three possibilities:
    * newNode is live and will require further branching to resolve
      (variable() >= 0). Increment the cut reference counts by
      numberBranches() to allow for use by children of this node, and
      decrement by 1 because we've executed one arm of the branch of our
      parent (consuming one reference). Before we push newNode onto the
      search tree, try for a heuristic solution.
    * We have a solution, in which case newNode is non-null but we have no
      branching variable. Decrement the cut counts and save the solution.
    * The node was found to be infeasible, in which case it's already been
      deleted, and newNode is null.
*/
        if (!eventHandler->event(CbcEventHandler::node)) {
          eventHappened_=true; // exit
        }
        assert (!newNode || newNode->objectiveValue() <= getCutoff()) ;
        if (statistics_) {
          assert (numberNodes2_);
          assert (statistics_[numberNodes2_-1]);
          assert (statistics_[numberNodes2_-1]->node()==numberNodes2_-1);
          if (newNode)
            statistics_[numberNodes2_-1]->updateInfeasibility(newNode->numberUnsatisfied());
          else
            statistics_[numberNodes2_-1]->sayInfeasible();
        }
        if (newNode) {
          if (newNode->branchingObject() == NULL&&solverCharacteristics_->solverType()==4) {
            // need to check if any cuts would do anything
            OsiCuts theseCuts;
            // reset probing info
            if (probingInfo_)
              probingInfo_->initializeFixing();
            for (int i = 0;i<numberCutGenerators_;i++) {
              bool generate = generator_[i]->normal();
              // skip if not optimal and should be (maybe a cut generator has fixed variables)
              if (generator_[i]->needsOptimalBasis()&&!solver_->basisIsAvailable())
                generate=false;
              if (!generator_[i]->mustCallAgain())
                generate=false; // only special cuts
              if (generate) {
                generator_[i]->generateCuts(theseCuts,true,solver_,NULL) ;
                int numberRowCutsAfter = theseCuts.sizeRowCuts() ;
                if (numberRowCutsAfter) {
                  // need dummy branch
                  newNode->setBranchingObject(new CbcDummyBranchingObject(this));
                  newNode->nodeInfo()->initializeInfo(1);
                  break;
                }
              }
            }
          }
          if (newNode->branchingObject())
          { handler_->message(CBC_BRANCH,messages_)
               << numberNodes_<< newNode->objectiveValue()
               << newNode->numberUnsatisfied()<< newNode->depth()
               << CoinMessageEol ;
            // Increment cut counts (taking off current)
            int numberLeft = newNode->numberBranches() ;
            for (i = 0;i < currentNumberCuts_;i++)
            { if (addedCuts_[i])
              {
#               ifdef CHECK_CUT_COUNTS
                printf("Count on cut %x increased by %d\n",addedCuts_[i],
                        numberLeft-1) ;
#               endif
                addedCuts_[i]->increment(numberLeft-1) ; } }

            double estValue = newNode->guessedObjectiveValue() ;
            int found = -1 ;
            // no - overhead on small problems solver_->resolve() ;     // double check current optimal
            // assert (!solver_->getIterationCount());
            double * newSolution = new double [numberColumns] ;
            double heurValue = getCutoff() ;
            int iHeur ;
            for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++)
            { double saveValue = heurValue ;
              int ifSol = heuristic_[iHeur]->solution(heurValue,newSolution) ;
              if (ifSol > 0) {
                // new solution found
                found = iHeur ;
                incrementUsed(newSolution);
              }
              else
              if (ifSol < 0)    // just returning an estimate
              { estValue = CoinMin(heurValue,estValue) ;
                heurValue = saveValue ; } }
            if (found >= 0) {
              lastHeuristic_ = heuristic_[found];
              setBestSolution(CBC_ROUNDING,heurValue,newSolution) ;
            }
            delete [] newSolution ;
            newNode->setGuessedObjectiveValue(estValue) ;
            tree_->push(newNode) ;
            if (statistics_) {
              if (numberNodes2_==maximumStatistics_) {
                maximumStatistics_ = 2*maximumStatistics_;
                CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
                memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
                memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
                delete [] statistics_;
                statistics_=temp;
              }
              assert (!statistics_[numberNodes2_]);
              statistics_[numberNodes2_]=new CbcStatistics(newNode);
            }
            numberNodes2_++;
#           ifdef CHECK_NODE
            printf("Node %x pushed on tree c\n",newNode) ;
#           endif
          }
          else
          { 
            if(solverCharacteristics_ && //we may be in a non standard bab
               solverCharacteristics_->solutionAddsCuts()// we are in some kind of OA based bab.
               )
              {
                std::cerr<<"You should never get here"<<std::endl;
                throw CoinError("Nodes should not be fathomed on integer infeasibility in this setting",
                                "branchAndBound","CbcModel") ;
              }
            for (i = 0 ; i < currentNumberCuts_ ; i++)
            { if (addedCuts_[i])
              { if (!addedCuts_[i]->decrement(1))
                  delete addedCuts_[i] ; } }
          double objectiveValue = newNode->objectiveValue();
            setBestSolution(CBC_SOLUTION,objectiveValue,
                            solver_->getColSolution()) ;
            lastHeuristic_ = NULL;
            incrementUsed(solver_->getColSolution());
            //assert(nodeInfo->numberPointingToThis() <= 2) ;
            // avoid accidental pruning, if newNode was final branch arm
            nodeInfo->increment();
            delete newNode ;
            nodeInfo->decrement() ; } }
/*
  This node has been completely expanded and can be removed from the live
  set.
*/
      if (branchesLeft)
      { 
      }
      else
      { 
        if (!nodeInfo->numberBranchesLeft())
          nodeInfo->allBranchesGone(); // can clean up
        delete node ; }
    } else {
      // add cuts found to be infeasible (on bound)!
      abort();
      delete node;
    }
/*
  Delete cuts to get back to the original system.

  I'm thinking this is redundant --- the call to addCuts that conditions entry
  to this code block also performs this action.
*/
      int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
      if (numberToDelete)
      { int * delRows = new int[numberToDelete] ;
        int i ;
        for (i = 0 ; i < numberToDelete ; i++)
        { delRows[i] = i+numberRowsAtContinuous_ ; }
        solver_->deleteRows(numberToDelete,delRows) ;
        delete [] delRows ; }
#else // end of not CBC_THREAD
      if (!numberThreads_) {
        doOneNode(this,node,createdNode);
      } else {
        threadStats[0]++;
        //need to think
        int iThread;
        // Start one off if any available
        for (iThread=0;iThread<numberThreads_;iThread++) {
          if (threadInfo[iThread].returnCode==-1) 
            break;
        }
        if (iThread<numberThreads_) {
          threadInfo[iThread].node=node;
          assert (threadInfo[iThread].returnCode==-1);
          // say in use
          threadInfo[iThread].returnCode=0;
          threadModel[iThread]->moveToModel(this,0);
          pthread_cond_signal(threadInfo[iThread].condition2); // unlock
          threadCount[iThread]++;
        }
        lockThread();
        locked=true;
        // see if any finished
        for (iThread=0;iThread<numberThreads_;iThread++) {
          if (threadInfo[iThread].returnCode>0) 
            break;
        }
        unlockThread();
        locked=false;
        if (iThread<numberThreads_) {
          threadModel[iThread]->moveToModel(this,1);
          assert (threadInfo[iThread].returnCode==1);
          // say available
          threadInfo[iThread].returnCode=-1;
          // carry on
          threadStats[3]++;
        } else {
          // Start one off if any available
          for (iThread=0;iThread<numberThreads_;iThread++) {
            if (threadInfo[iThread].returnCode==-1) 
              break;
          }
          if (iThread<numberThreads_) {
            lockThread();
            locked=true;
            // If any on tree get
            if (!tree_->empty()) {
              //node = tree_->bestNode(cutoff) ;
              //assert (node);
              threadStats[1]++;
              continue; // ** get another node
            }
            unlockThread();
            locked=false;
          }
          // wait (for debug could sleep and use test)
          bool finished=false;
          while (!finished) {
            pthread_mutex_lock(&condition_mutex);
            struct timespec absTime;
            clock_gettime(CLOCK_REALTIME,&absTime);
            double time = absTime.tv_sec+1.0e-9*absTime.tv_nsec;
            absTime.tv_nsec += 1000000; // millisecond
            if (absTime.tv_nsec>=1000000000) {
              absTime.tv_nsec -= 1000000000;
              absTime.tv_sec++;
            }
            pthread_cond_timedwait(&condition_main,&condition_mutex,&absTime);
            clock_gettime(CLOCK_REALTIME,&absTime);
            double time2 = absTime.tv_sec+1.0e-9*absTime.tv_nsec;
            timeWaiting += time2-time;
            pthread_mutex_unlock(&condition_mutex);
            for (iThread=0;iThread<numberThreads_;iThread++) {
              if (threadInfo[iThread].returnCode>0) {
                finished=true;
                break;
              } else if (threadInfo[iThread].returnCode==0) {
                pthread_cond_signal(threadInfo[iThread].condition2); // unlock
              }
            }
          }
          assert (iThread<numberThreads_);
          threadModel[iThread]->moveToModel(this,1);
          node = threadInfo[iThread].node;
          threadInfo[iThread].node=NULL;
          assert (threadInfo[iThread].returnCode==1);
          // say available
          threadInfo[iThread].returnCode=-1;
          // carry on
          threadStats[2]++;
        }
      }
      //lastDepth=node->depth();
      //lastUnsatisfied=node->numberUnsatisfied();
#endif // end of CBC_THREAD
  }
#ifdef CBC_THREAD
  if (numberThreads_) {
    //printf("stats ");
    //for (unsigned int j=0;j<sizeof(threadStats)/sizeof(int);j++)
    //printf("%d ",threadStats[j]);
    //printf("\n");
    int i;
    // Seems to be bug in CoinCpu on Linux - does threads as well despite documentation
    double time=0.0;
    for (i=0;i<numberThreads_;i++) 
      time += threadInfo[i].timeInThread;
    bool goodTimer = time<(getCurrentSeconds());
    //bool stopped = (!(numberNodes_ < intParam_[CbcMaxNumNode] &&
    //        numberSolutions_ < intParam_[CbcMaxNumSol] &&
    //        totalTime < dblParam_[CbcMaximumSeconds] &&
    //        !stoppedOnGap_&&!eventHappened_));
    for (i=0;i<numberThreads_;i++) {
      while (threadInfo[i].returnCode==0) {
        pthread_cond_signal(threadInfo[i].condition2); // unlock
        pthread_mutex_lock(&condition_mutex);
        struct timespec absTime;
        clock_gettime(CLOCK_REALTIME,&absTime);
        absTime.tv_nsec += 1000000; // millisecond
        if (absTime.tv_nsec>=1000000000) {
          absTime.tv_nsec -= 1000000000;
          absTime.tv_sec++;
        }
        pthread_cond_timedwait(&condition_main,&condition_mutex,&absTime);
        clock_gettime(CLOCK_REALTIME,&absTime);
        pthread_mutex_unlock(&condition_mutex);
      }
      pthread_cond_signal(threadInfo[i].condition2); // unlock
      pthread_mutex_lock(&condition_mutex); // not sure necessary but have had one hang on interrupt
      threadModel[i]->numberThreads_=0; // say exit
      threadInfo[i].returnCode=0;
      pthread_mutex_unlock(&condition_mutex);
      pthread_cond_signal(threadInfo[i].condition2); // unlock
      //if (!stopped)
      //pthread_join(threadId[i],NULL);
      int returnCode;
      returnCode=pthread_join(threadId[i],NULL);
      assert (!returnCode);
        //else
        //pthread_kill(threadId[i]); // kill rather than try and synchronize
      threadModel[i]->moveToModel(this,2);
      pthread_mutex_destroy (threadInfo[i].mutex2);
      pthread_cond_destroy (threadInfo[i].condition2);
      assert (threadInfo[i].numberTimesLocked==threadInfo[i].numberTimesUnlocked);
      handler_->message(CBC_THREAD_STATS,messages_)
        <<"Thread";
      handler_->printing(true)
        <<i<<threadCount[i]<<threadInfo[i].timeWaitingToStart;
      handler_->printing(goodTimer)<<threadInfo[i].timeInThread;
      handler_->printing(false)<<0.0;
      handler_->printing(true)<<threadInfo[i].numberTimesLocked
        <<threadInfo[i].timeLocked<<threadInfo[i].timeWaitingToLock
        <<CoinMessageEol;
    }
    assert (threadInfo[numberThreads_].numberTimesLocked==threadInfo[numberThreads_].numberTimesUnlocked);
    handler_->message(CBC_THREAD_STATS,messages_)
      <<"Main thread";
    handler_->printing(false)<<0<<0<<0.0;
    handler_->printing(false)<<0.0;
    handler_->printing(true)<<timeWaiting;
    handler_->printing(true)<<threadInfo[numberThreads_].numberTimesLocked
      <<threadInfo[numberThreads_].timeLocked<<threadInfo[numberThreads_].timeWaitingToLock
      <<CoinMessageEol;
    pthread_mutex_destroy (&mutex);
    pthread_cond_destroy (&condition_main);
    pthread_mutex_destroy (&condition_mutex);
    // delete models (here in case some point to others)
    for (i=0;i<numberThreads_;i++) {
      delete threadModel[i];
    }
    delete [] mutex2;
    delete [] condition2;
    delete [] threadId;
    delete [] threadInfo;
    delete [] threadModel;
    delete [] threadCount;
    mutex_=NULL;
    // adjust time to allow for children on some systems
    dblParam_[CbcStartSeconds] -= CoinCpuTimeJustChildren();
  }
#endif
/*
  End of the non-abort actions. The next block of code is executed if we've
  aborted because we hit one of the limits. Clean up by deleting the live set
  and break out of the node processing loop. Note that on an abort, node may
  have been pushed back onto the tree for further processing, in which case
  it'll be deleted in cleanTree. We need to check.
*/
    if (!(numberNodes_ < intParam_[CbcMaxNumNode] &&
        numberSolutions_ < intParam_[CbcMaxNumSol] &&
        totalTime < dblParam_[CbcMaximumSeconds] &&
        !stoppedOnGap_&&!eventHappened_)) {
      if (tree_->size())
        tree_->cleanTree(this,-COIN_DBL_MAX,bestPossibleObjective_) ;
      delete nextRowCut_;
      if (stoppedOnGap_)
        { messageHandler()->message(CBC_GAP,messages())
          << bestObjective_-bestPossibleObjective_
          << dblParam_[CbcAllowableGap]
          << dblParam_[CbcAllowableFractionGap]*100.0
          << CoinMessageEol ;
        secondaryStatus_ = 2;
        status_ = 0 ; }
        else
          if (isNodeLimitReached())
            { handler_->message(CBC_MAXNODES,messages_) << CoinMessageEol ;
            secondaryStatus_ = 3;
            status_ = 1 ; }
          else
        if (totalTime >= dblParam_[CbcMaximumSeconds])
          { handler_->message(CBC_MAXTIME,messages_) << CoinMessageEol ; 
          secondaryStatus_ = 4;
          status_ = 1 ; }
        else
          if (eventHappened_)
            { handler_->message(CBC_EVENT,messages_) << CoinMessageEol ; 
            secondaryStatus_ = 5;
            status_ = 5 ; }
          else
            { handler_->message(CBC_MAXSOLS,messages_) << CoinMessageEol ;
            secondaryStatus_ = 6;
            status_ = 1 ; }
    }
/*
  That's it, we've exhausted the search tree, or broken out of the loop because
  we hit some limit on evaluation.

  We may have got an intelligent tree so give it one more chance
*/
  // Tell solver we are not in Branch and Cut
  solver_->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo,NULL) ;
  tree_->endSearch();
  //  If we did any sub trees - did we give up on any?
  if ( numberStoppedSubTrees_)
    status_=1;
  if (!status_) {
    // Set best possible unless stopped on gap
    if(secondaryStatus_ != 2)
      bestPossibleObjective_=bestObjective_;
    handler_->message(CBC_END_GOOD,messages_)
      << bestObjective_ << numberIterations_ << numberNodes_<<getCurrentSeconds()
      << CoinMessageEol ;
  } else {
    handler_->message(CBC_END,messages_)
      << bestObjective_ <<bestPossibleObjective_
      << numberIterations_ << numberNodes_<<getCurrentSeconds()
      << CoinMessageEol ;
  }
  if (numberStrongIterations_)
    handler_->message(CBC_STRONG_STATS,messages_)
      << strongInfo_[0] << numberStrongIterations_ << strongInfo_[2]
      << strongInfo_[1] << CoinMessageEol ;
  handler_->message(CBC_OTHER_STATS,messages_)
      << maximumDepthActual_ 
      << numberDJFixed_ << CoinMessageEol ;
  if (doStatistics==100) {
    for (int i=0;i<numberObjects_;i++) {
      CbcSimpleIntegerDynamicPseudoCost * obj =
        dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
      if (obj)
        obj->print();
    }
  }
  if (statistics_) {
    // report in some way
    int * lookup = new int[numberObjects_];
    int i;
    for (i=0;i<numberObjects_;i++) 
      lookup[i]=-1;
    bool goodIds=true;
    for (i=0;i<numberObjects_;i++) {
      int iColumn = object_[i]->columnNumber();
      if(iColumn>=0&&iColumn<numberColumns) {
        if (lookup[i]==-1) {
          lookup[i]=iColumn;
        } else {
          goodIds=false;
          break;
        }
      } else {
        goodIds=false;
        break;
      }
    }
    if (!goodIds) {
      delete [] lookup;
      lookup=NULL;
    }
    if (doStatistics==3) {
      printf("  node parent depth column   value                    obj      inf\n");
      for ( i=0;i<numberNodes2_;i++) {
        statistics_[i]->print(lookup);
      }
    }
    if (doStatistics>1) {
      // Find last solution
      int k;
      for (k=numberNodes2_-1;k>=0;k--) {
        if (statistics_[k]->endingObjective()!=COIN_DBL_MAX&&
            !statistics_[k]->endingInfeasibility())
          break;
      }
      if (k>=0) {
        int depth=statistics_[k]->depth();
        int * which = new int[depth+1];
        for (i=depth;i>=0;i--) {
          which[i]=k;
          k=statistics_[k]->parentNode();
        }
        printf("  node parent depth column   value                    obj      inf\n");
        for (i=0;i<=depth;i++) {
          statistics_[which[i]]->print(lookup);
        }
        delete [] which;
      }
    }
    // now summary
    int maxDepth=0;
    double averageSolutionDepth=0.0;
    int numberSolutions=0;
    double averageCutoffDepth=0.0;
    double averageSolvedDepth=0.0;
    int numberCutoff=0;
    int numberDown=0;
    int numberFirstDown=0;
    double averageInfDown=0.0;
    double averageObjDown=0.0;
    int numberCutoffDown=0;
    int numberUp=0;
    int numberFirstUp=0;
    double averageInfUp=0.0;
    double averageObjUp=0.0;
    int numberCutoffUp=0;
    double averageNumberIterations1=0.0;
    double averageValue=0.0;
    for ( i=0;i<numberNodes2_;i++) {
      int depth =  statistics_[i]->depth(); 
      int way =  statistics_[i]->way(); 
      double value = statistics_[i]->value(); 
      double startingObjective =  statistics_[i]->startingObjective(); 
      int startingInfeasibility = statistics_[i]->startingInfeasibility(); 
      double endingObjective = statistics_[i]->endingObjective(); 
      int endingInfeasibility = statistics_[i]->endingInfeasibility(); 
      maxDepth = CoinMax(depth,maxDepth);
      // Only for completed
      averageNumberIterations1 += statistics_[i]->numberIterations();
      averageValue += value;
      if (endingObjective!=COIN_DBL_MAX&&!endingInfeasibility) {
        numberSolutions++;
        averageSolutionDepth += depth;
      }
      if (endingObjective==COIN_DBL_MAX) {
        numberCutoff++;
        averageCutoffDepth += depth;
        if (way<0) {
          numberDown++;
          numberCutoffDown++;
          if (way==-1)
            numberFirstDown++;
        } else {
          numberUp++;
          numberCutoffUp++;
          if (way==1)
            numberFirstUp++;
        }
      } else {
        averageSolvedDepth += depth;
        if (way<0) {
          numberDown++;
          averageInfDown += startingInfeasibility-endingInfeasibility;
          averageObjDown += endingObjective-startingObjective;
          if (way==-1)
            numberFirstDown++;
        } else {
          numberUp++;
          averageInfUp += startingInfeasibility-endingInfeasibility;
          averageObjUp += endingObjective-startingObjective;
          if (way==1)
            numberFirstUp++;
        }
      }
    }
    // Now print
    if (numberSolutions)
      averageSolutionDepth /= (double) numberSolutions;
    int numberSolved = numberNodes2_-numberCutoff;
    double averageNumberIterations2=numberIterations_-averageNumberIterations1
      -numberIterationsAtContinuous;
    if(numberCutoff) {
      averageCutoffDepth /= (double) numberCutoff;
      averageNumberIterations2 /= (double) numberCutoff;
    }
    if (numberNodes2_) 
      averageValue /= (double) numberNodes2_;
    if (numberSolved) {
      averageNumberIterations1 /= (double) numberSolved;
      averageSolvedDepth /= (double) numberSolved;
    }
    printf("%d solution(s) were found (by branching) at an average depth of %g\n",
           numberSolutions,averageSolutionDepth);
    printf("average value of variable being branched on was %g\n",
           averageValue);
    printf("%d nodes were cutoff at an average depth of %g with iteration count of %g\n",
           numberCutoff,averageCutoffDepth,averageNumberIterations2);
    printf("%d nodes were solved at an average depth of %g with iteration count of %g\n",
           numberSolved,averageSolvedDepth,averageNumberIterations1);
    if (numberDown) {
      averageInfDown /= (double) numberDown;
      averageObjDown /= (double) numberDown;
    }
    printf("Down %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
           numberDown,numberFirstDown,numberDown-numberFirstDown,numberCutoffDown,
           averageInfDown,averageObjDown);
    if (numberUp) {
      averageInfUp /= (double) numberUp;
      averageObjUp /= (double) numberUp;
    }
    printf("Up %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
           numberUp,numberFirstUp,numberUp-numberFirstUp,numberCutoffUp,
           averageInfUp,averageObjUp);
    for ( i=0;i<numberNodes2_;i++) 
      delete statistics_[i];
    delete [] statistics_;
    statistics_=NULL;
    maximumStatistics_=0;
    delete [] lookup;
  }
/*
  If we think we have a solution, restore and confirm it with a call to
  setBestSolution().  We need to reset the cutoff value so as not to fathom
  the solution on bounds.  Note that calling setBestSolution( ..., true)
  leaves the continuousSolver_ bounds vectors fixed at the solution value.

  Running resolve() here is a failsafe --- setBestSolution has already
  reoptimised using the continuousSolver_. If for some reason we fail to
  prove optimality, run the problem again after instructing the solver to
  tell us more.

  If all looks good, replace solver_ with continuousSolver_, so that the
  outside world will be able to obtain information about the solution using
  public methods.
*/
  if (bestSolution_&&(solverCharacteristics_->solverType()<2||solverCharacteristics_->solverType()==4)) 
  { setCutoff(1.0e50) ; // As best solution should be worse than cutoff
    phase_=5;
    double increment = getDblParam(CbcModel::CbcCutoffIncrement) ;
    if ((specialOptions_&4)!=0)
      bestObjective_ += 100.0*increment+1.0e-3; // only set if we are going to solve
    setBestSolution(CBC_END_SOLUTION,bestObjective_,bestSolution_,true) ;
    continuousSolver_->resolve() ;
    if (!continuousSolver_->isProvenOptimal())
    { continuousSolver_->messageHandler()->setLogLevel(2) ;
      continuousSolver_->initialSolve() ; }
    delete solver_ ;
    // above deletes solverCharacteristics_
    solverCharacteristics_ = NULL;
    solver_ = continuousSolver_ ;
    setPointers(solver_);
    continuousSolver_ = NULL ; }
/*
  Clean up dangling objects. continuousSolver_ may already be toast.
*/
  delete lastws ;
  delete [] whichGenerator_ ;
  whichGenerator_=NULL;
  delete [] lowerBefore ;
  delete [] upperBefore ;
  delete [] walkback_ ;
  walkback_ = NULL ;
  delete [] addedCuts_ ;
  addedCuts_ = NULL ;
  //delete persistentInfo;
  // Get rid of characteristics
  solverCharacteristics_=NULL;
  if (continuousSolver_)
  { delete continuousSolver_ ;
    continuousSolver_ = NULL ; }
/*
  Destroy global cuts by replacing with an empty OsiCuts object.
*/
  globalCuts_= OsiCuts() ;
  if (!bestSolution_) {
    // make sure lp solver is infeasible
    int numberColumns = solver_->getNumCols();
    const double * columnLower = solver_->getColLower();
    int iColumn;
    for (iColumn=0;iColumn<numberColumns;iColumn++) {
      if (solver_->isInteger(iColumn)) 
        solver_->setColUpper(iColumn,columnLower[iColumn]);
    }
    solver_->initialSolve();
  }
  if (strategy_&&strategy_->preProcessState()>0) {
    // undo preprocessing
    CglPreProcess * process = strategy_->process();
    assert (process);
    int n = originalSolver->getNumCols();
    if (bestSolution_) {
      delete [] bestSolution_;
      bestSolution_ = new double [n];
      process->postProcess(*solver_);
    }
    strategy_->deletePreProcess();
    // Solution now back in originalSolver
    delete solver_;
    solver_=originalSolver;
    if (bestSolution_)
      memcpy(bestSolution_,solver_->getColSolution(),n*sizeof(double));
    // put back original objects if there were any
    if (originalObject) {
      int iColumn;
      assert (ownObjects_);
      for (iColumn=0;iColumn<numberObjects_;iColumn++) 
        delete object_[iColumn];
      delete [] object_;
      numberObjects_ = numberOriginalObjects;
      object_=originalObject;
      delete [] integerVariable_;
      numberIntegers_=0;
      for (iColumn=0;iColumn<n;iColumn++) {
        if (solver_->isInteger(iColumn))
          numberIntegers_++;
      }
      integerVariable_ = new int[numberIntegers_];
      numberIntegers_=0;
      for (iColumn=0;iColumn<n;iColumn++) {
        if (solver_->isInteger(iColumn))
            integerVariable_[numberIntegers_++]=iColumn;
      }
    }
  }
#ifdef CLP_QUICK_OPTIONS
  {
    OsiClpSolverInterface * clpSolver 
      = dynamic_cast<OsiClpSolverInterface *> (solver_);
    if (clpSolver) {
      // Try and re-use regions   
      ClpSimplex * simplex = clpSolver->getModelPtr();
      simplex->setPersistenceFlag(0);
      clpSolver->deleteScaleFactors();
      clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~131072));
      simplex->setSpecialOptions(simplex->specialOptions()&(~131072));
      simplex->setAlphaAccuracy(-1.0);
      //clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
    }
  }
#endif
  return ;
 }


// Solve the initial LP relaxation 
void 
CbcModel::initialSolve() 
{
  assert (solver_);
  assert (!solverCharacteristics_);
  OsiBabSolver * solverCharacteristics = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
  if (solverCharacteristics) {
    solverCharacteristics_ = solverCharacteristics;
  } else {
    // replace in solver
    OsiBabSolver defaultC;
    solver_->setAuxiliaryInfo(&defaultC);
    solverCharacteristics_ = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
  }
  solverCharacteristics_->setSolver(solver_);
  solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
  solver_->initialSolve();
  solver_->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo,NULL) ;
  // But set up so Jon Lee will be happy
  status_=-1;
  secondaryStatus_ = -1;
  originalContinuousObjective_ = solver_->getObjValue()*solver_->getObjSense();
  delete [] continuousSolution_;
  continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),
                                             solver_->getNumCols());
  setPointers(solver_);
  solverCharacteristics_ = NULL;
}

/*! \brief Get an empty basis object

  Return an empty CoinWarmStartBasis object with the requested capacity,
  appropriate for the current solver. The object is cloned from the object
  cached as emptyWarmStart_. If there is no cached object, the routine
  queries the solver for a warm start object, empties it, and caches the
  result.
*/

CoinWarmStartBasis *CbcModel::getEmptyBasis (int ns, int na) const

{ CoinWarmStartBasis *emptyBasis ;
/*
  Acquire an empty basis object, if we don't yet have one.
*/
  if (emptyWarmStart_ == 0)
  { if (solver_ == 0)
    { throw CoinError("Cannot construct basis without solver!",
                      "getEmptyBasis","CbcModel") ; }
    emptyBasis =
        dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart()) ;
    if (emptyBasis == 0)
    { throw CoinError(
        "Solver does not appear to use a basis-oriented warm start.",
        "getEmptyBasis","CbcModel") ; }
    emptyBasis->setSize(0,0) ;
    emptyWarmStart_ = dynamic_cast<CoinWarmStart *>(emptyBasis) ; }
/*
  Clone the empty basis object, resize it as requested, and return.
*/
  emptyBasis = dynamic_cast<CoinWarmStartBasis *>(emptyWarmStart_->clone()) ;
  assert(emptyBasis) ;
  if (ns != 0 || na != 0) emptyBasis->setSize(ns,na) ;

  return (emptyBasis) ; }
    

/** Default Constructor

  Creates an empty model without an associated solver.
*/
CbcModel::CbcModel() 

:
  solver_(NULL),
  ourSolver_(true),
  continuousSolver_(NULL),
  referenceSolver_(NULL),
  defaultHandler_(true),
  emptyWarmStart_(NULL),
  bestObjective_(COIN_DBL_MAX),
  bestPossibleObjective_(COIN_DBL_MAX),
  sumChangeObjective1_(0.0),
  sumChangeObjective2_(0.0),
  bestSolution_(NULL),
  currentSolution_(NULL),
  testSolution_(NULL),
  minimumDrop_(1.0e-4),
  numberSolutions_(0),
  stateOfSearch_(0),
  hotstartSolution_(NULL),
  hotstartPriorities_(NULL),
  numberHeuristicSolutions_(0),
  numberNodes_(0),
  numberNodes2_(0),
  numberIterations_(0),
  status_(-1),
  secondaryStatus_(-1),
  numberIntegers_(0),
  numberRowsAtContinuous_(0),
  maximumNumberCuts_(0),
  phase_(0),
  currentNumberCuts_(0),
  maximumDepth_(0),
  walkback_(NULL),
  addedCuts_(NULL),
  nextRowCut_(NULL),
  currentNode_(NULL),
  integerVariable_(NULL),
  integerInfo_(NULL),
  continuousSolution_(NULL),
  usedInSolution_(NULL),
  specialOptions_(0),
  subTreeModel_(NULL),
  numberStoppedSubTrees_(0),
  mutex_(NULL),
  presolve_(0),
  numberStrong_(5),
  numberBeforeTrust_(10),
  numberPenalties_(20),
  penaltyScaleFactor_(3.0),
  numberAnalyzeIterations_(0),
  analyzeResults_(NULL),
  numberInfeasibleNodes_(0),
  problemType_(0),
  printFrequency_(0),
  numberCutGenerators_(0),
  generator_(NULL),
  virginGenerator_(NULL),
  numberHeuristics_(0),
  heuristic_(NULL),
  lastHeuristic_(NULL),
  eventHandler_(0),
  numberObjects_(0),
  object_(NULL),
  ownObjects_(true),
  originalColumns_(NULL),
  howOftenGlobalScan_(1),
  numberGlobalViolations_(0),
  continuousObjective_(COIN_DBL_MAX),
  originalContinuousObjective_(COIN_DBL_MAX),
  continuousInfeasibilities_(COIN_INT_MAX),
  maximumCutPassesAtRoot_(20),
  maximumCutPasses_(10),
  preferredWay_(0),
  currentPassNumber_(0),
  maximumWhich_(1000),
  whichGenerator_(NULL),
  maximumStatistics_(0),
  statistics_(NULL),
  maximumDepthActual_(0),
  numberDJFixed_(0.0),
  probingInfo_(NULL),
  numberFixedAtRoot_(0),
  numberFixedNow_(0),
  stoppedOnGap_(false),
  eventHappened_(false),
  numberLongStrong_(0),
  numberOldActiveCuts_(0),
  numberNewCuts_(0),
  sizeMiniTree_(0),
  searchStrategy_(-1),
  numberStrongIterations_(0),
  resolveAfterTakeOffCuts_(true),
#if NEW_UPDATE_OBJECT>1
  numberUpdateItems_(0),
  maximumNumberUpdateItems_(0),
  updateItems_(NULL),
#endif
  numberThreads_(0),
  threadMode_(0)
{
  memset(intParam_,0,sizeof(intParam_));
  intParam_[CbcMaxNumNode] = 2147483647;
  intParam_[CbcMaxNumSol] = 9999999;
  intParam_[CbcFathomDiscipline] = 0;

  dblParam_[CbcIntegerTolerance] = 1e-6;
  dblParam_[CbcInfeasibilityWeight] = 0.0;
  dblParam_[CbcCutoffIncrement] = 1e-5;
  dblParam_[CbcAllowableGap] = 1.0e-10;
  dblParam_[CbcAllowableFractionGap] = 0.0;
  dblParam_[CbcMaximumSeconds] = 1.0e100;
  dblParam_[CbcCurrentCutoff] = 1.0e100;
  dblParam_[CbcOptimizationDirection] = 1.0;
  dblParam_[CbcCurrentObjectiveValue] = 1.0e100;
  dblParam_[CbcCurrentMinimizationObjectiveValue] = 1.0e100;
  dblParam_[CbcStartSeconds] = 0.0;
  strongInfo_[0]=0;
  strongInfo_[1]=0;
  strongInfo_[2]=0;
  solverCharacteristics_ = NULL;
  nodeCompare_=new CbcCompareDefault();;
  problemFeasibility_=new CbcFeasibilityBase();
  tree_= new CbcTree();
  branchingMethod_=NULL;
  cutModifier_=NULL;
  strategy_=NULL;
  parentModel_=NULL;
  cbcColLower_ = NULL;
  cbcColUpper_ = NULL;
  cbcRowLower_ = NULL;
  cbcRowUpper_ = NULL;
  cbcColSolution_ = NULL;
  cbcRowPrice_ = NULL;
  cbcReducedCost_ = NULL;
  cbcRowActivity_ = NULL;
  appData_=NULL;
  handler_ = new CoinMessageHandler();
  handler_->setLogLevel(2);
  messages_ = CbcMessage();
  eventHandler_ = new CbcEventHandler() ;
}

/** Constructor from solver.

  Creates a model complete with a clone of the solver passed as a parameter.
*/

CbcModel::CbcModel(const OsiSolverInterface &rhs)
:
  continuousSolver_(NULL),
  referenceSolver_(NULL),
  defaultHandler_(true),
  emptyWarmStart_(NULL),
  bestObjective_(COIN_DBL_MAX),
  bestPossibleObjective_(COIN_DBL_MAX),
  sumChangeObjective1_(0.0),
  sumChangeObjective2_(0.0),
  minimumDrop_(1.0e-4),
  numberSolutions_(0),
  stateOfSearch_(0),
  hotstartSolution_(NULL),
  hotstartPriorities_(NULL),
  numberHeuristicSolutions_(0),
  numberNodes_(0),
  numberNodes2_(0),
  numberIterations_(0),
  status_(-1),
  secondaryStatus_(-1),
  numberRowsAtContinuous_(0),
  maximumNumberCuts_(0),
  phase_(0),
  currentNumberCuts_(0),
  maximumDepth_(0),
  walkback_(NULL),
  addedCuts_(NULL),
  nextRowCut_(NULL),
  currentNode_(NULL),
  integerInfo_(NULL),
  specialOptions_(0),
  subTreeModel_(NULL),
  numberStoppedSubTrees_(0),
  mutex_(NULL),
  presolve_(0),
  numberStrong_(5),
  numberBeforeTrust_(10),
  numberPenalties_(20),
  penaltyScaleFactor_(3.0),
  numberAnalyzeIterations_(0),
  analyzeResults_(NULL),
  numberInfeasibleNodes_(0),
  problemType_(0),
  printFrequency_(0),
  numberCutGenerators_(0),
  generator_(NULL),
  virginGenerator_(NULL),
  numberHeuristics_(0),
  heuristic_(NULL),
  lastHeuristic_(NULL),
  eventHandler_(0),
  numberObjects_(0),
  object_(NULL),
  ownObjects_(true),
  originalColumns_(NULL),
  howOftenGlobalScan_(1),
  numberGlobalViolations_(0),
  continuousObjective_(COIN_DBL_MAX),
  originalContinuousObjective_(COIN_DBL_MAX),
  continuousInfeasibilities_(COIN_INT_MAX),
  maximumCutPassesAtRoot_(20),
  maximumCutPasses_(10),
  preferredWay_(0),
  currentPassNumber_(0),
  maximumWhich_(1000),
  whichGenerator_(NULL),
  maximumStatistics_(0),
  statistics_(NULL),
  maximumDepthActual_(0),
  numberDJFixed_(0.0),
  probingInfo_(NULL),
  numberFixedAtRoot_(0),
  numberFixedNow_(0),
  stoppedOnGap_(false),
  eventHappened_(false),
  numberLongStrong_(0),
  numberOldActiveCuts_(0),
  numberNewCuts_(0),
  sizeMiniTree_(0),
  searchStrategy_(-1),
  numberStrongIterations_(0),
  resolveAfterTakeOffCuts_(true),
#if NEW_UPDATE_OBJECT>1
  numberUpdateItems_(0),
  maximumNumberUpdateItems_(0),
  updateItems_(NULL),
#endif
  numberThreads_(0),
  threadMode_(0)
{
  memset(intParam_,0,sizeof(intParam_));
  intParam_[CbcMaxNumNode] = 2147483647;
  intParam_[CbcMaxNumSol] = 9999999;
  intParam_[CbcFathomDiscipline] = 0;

  dblParam_[CbcIntegerTolerance] = 1e-6;
  dblParam_[CbcInfeasibilityWeight] = 0.0;
  dblParam_[CbcCutoffIncrement] = 1e-5;
  dblParam_[CbcAllowableGap] = 1.0e-10;
  dblParam_[CbcAllowableFractionGap] = 0.0;
  dblParam_[CbcMaximumSeconds] = 1.0e100;
  dblParam_[CbcCurrentCutoff] = 1.0e100;
  dblParam_[CbcOptimizationDirection] = 1.0;
  dblParam_[CbcCurrentObjectiveValue] = 1.0e100;
  dblParam_[CbcCurrentMinimizationObjectiveValue] = 1.0e100;
  dblParam_[CbcStartSeconds] = 0.0;
  strongInfo_[0]=0;
  strongInfo_[1]=0;
  strongInfo_[2]=0;
  solverCharacteristics_ = NULL;

  nodeCompare_=new CbcCompareDefault();;
  problemFeasibility_=new CbcFeasibilityBase();
  tree_= new CbcTree();
  branchingMethod_=NULL;
  cutModifier_=NULL;
  strategy_=NULL;
  parentModel_=NULL;
  appData_=NULL;
  handler_ = new CoinMessageHandler();
  handler_->setLogLevel(2);
  messages_ = CbcMessage();
  eventHandler_ = new CbcEventHandler() ;
  solver_ = rhs.clone();
  referenceSolver_ = solver_->clone();
  ourSolver_ = true ;
  cbcColLower_ = NULL;
  cbcColUpper_ = NULL;
  cbcRowLower_ = NULL;
  cbcRowUpper_ = NULL;
  cbcColSolution_ = NULL;
  cbcRowPrice_ = NULL;
  cbcReducedCost_ = NULL;
  cbcRowActivity_ = NULL;

  // Initialize solution and integer variable vectors
  bestSolution_ = NULL; // to say no solution found
  numberIntegers_=0;
  int numberColumns = solver_->getNumCols();
  int iColumn;
  if (numberColumns) {
    // Space for current solution
    currentSolution_ = new double[numberColumns];
    continuousSolution_ = new double[numberColumns];
    usedInSolution_ = new int[numberColumns];
    for (iColumn=0;iColumn<numberColumns;iColumn++) {
      if( solver_->isInteger(iColumn)) 
        numberIntegers_++;
    }
  } else {
    // empty model
    currentSolution_=NULL;
    continuousSolution_=NULL;
    usedInSolution_=NULL;
  }
  testSolution_=currentSolution_;
  if (numberIntegers_) {
    integerVariable_ = new int [numberIntegers_];
    numberIntegers_=0;
    for (iColumn=0;iColumn<numberColumns;iColumn++) {
      if( solver_->isInteger(iColumn)) 
        integerVariable_[numberIntegers_++]=iColumn;
    }
  } else {
    integerVariable_ = NULL;
  }
}

/*
  Assign a solver to the model (model assumes ownership)

  The integer variable vector is initialized if it's not already present.
  If deleteSolver then current solver deleted (if model owned)

  Assuming ownership matches usage in OsiSolverInterface
  (cf. assignProblem, loadProblem).

  TODO: What to do about solver parameters? A simple copy likely won't do it,
        because the SI must push the settings into the underlying solver. In
        the context of switching solvers in cbc, this means that command line
        settings will get lost. Stash the command line somewhere and reread it
        here, maybe?
  
  TODO: More generally, how much state should be transferred from the old
        solver to the new solver? Best perhaps to see how usage develops.
        What's done here mimics the CbcModel(OsiSolverInterface) constructor.
*/
void
CbcModel::assignSolver(OsiSolverInterface *&solver, bool deleteSolver)

{
  // resize best solution if exists
  if (bestSolution_&&solver&&solver_) {
    int nOld = solver_->getNumCols();
    int nNew = solver->getNumCols();
    if (nNew>nOld) {
      double * temp = new double[nNew];
      memcpy(temp,bestSolution_,nOld*sizeof(double));
      memset(temp+nOld,0,(nNew-nOld)*sizeof(double));
      delete [] bestSolution_;
      bestSolution_=temp;
    }
  }
  // Keep the current message level for solver (if solver exists)
  if (solver_)
    solver->messageHandler()->setLogLevel(solver_->messageHandler()->logLevel()) ;

  if (ourSolver_&&deleteSolver) delete solver_ ;
  solver_ = solver;
  solver = NULL ;
  ourSolver_ = true ;
/*
  Basis information is solver-specific.
*/
  if (emptyWarmStart_)
  { delete emptyWarmStart_  ;
    emptyWarmStart_ = 0 ; }
  bestSolutionBasis_ = CoinWarmStartBasis();
/*
  Initialize integer variable vector.
*/
  numberIntegers_=0;
  int numberColumns = solver_->getNumCols();
  int iColumn;
  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    if( solver_->isInteger(iColumn)) 
      numberIntegers_++;
  }
  delete [] integerVariable_;
  if (numberIntegers_) {
    integerVariable_ = new int [numberIntegers_];
    numberIntegers_=0;
    for (iColumn=0;iColumn<numberColumns;iColumn++) {
      if( solver_->isInteger(iColumn)) 
        integerVariable_[numberIntegers_++]=iColumn;
    }
  } else {
    integerVariable_ = NULL;
  }

  return ;
}

// Copy constructor.

CbcModel::CbcModel(const CbcModel & rhs, bool noTree)
:
  continuousSolver_(NULL),
  referenceSolver_(NULL),
  defaultHandler_(rhs.defaultHandler_),
  emptyWarmStart_(NULL),
  bestObjective_(rhs.bestObjective_),
  bestPossibleObjective_(rhs.bestPossibleObjective_),
  sumChangeObjective1_(rhs.sumChangeObjective1_),
  sumChangeObjective2_(rhs.sumChangeObjective2_),
  minimumDrop_(rhs.minimumDrop_),
  numberSolutions_(rhs.numberSolutions_),
  stateOfSearch_(rhs.stateOfSearch_),
  numberHeuristicSolutions_(rhs.numberHeuristicSolutions_),
  numberNodes_(rhs.numberNodes_),
  numberNodes2_(rhs.numberNodes2_),
  numberIterations_(rhs.numberIterations_),
  status_(rhs.status_),
  secondaryStatus_(rhs.secondaryStatus_),
  specialOptions_(rhs.specialOptions_),
  subTreeModel_(rhs.subTreeModel_),
  numberStoppedSubTrees_(rhs.numberStoppedSubTrees_),
  mutex_(NULL),
  presolve_(rhs.presolve_),
  numberStrong_(rhs.numberStrong_),
  numberBeforeTrust_(rhs.numberBeforeTrust_),
  numberPenalties_(rhs.numberPenalties_),
  penaltyScaleFactor_(rhs.penaltyScaleFactor_),
  numberAnalyzeIterations_(rhs.numberAnalyzeIterations_),
  analyzeResults_(NULL),
  numberInfeasibleNodes_(rhs.numberInfeasibleNodes_),
  problemType_(rhs.problemType_),
  printFrequency_(rhs.printFrequency_),
  howOftenGlobalScan_(rhs.howOftenGlobalScan_),
  numberGlobalViolations_(rhs.numberGlobalViolations_),
  continuousObjective_(rhs.continuousObjective_),
  originalContinuousObjective_(rhs.originalContinuousObjective_),
  continuousInfeasibilities_(rhs.continuousInfeasibilities_),
  maximumCutPassesAtRoot_(rhs.maximumCutPassesAtRoot_),
  maximumCutPasses_( rhs.maximumCutPasses_),
  preferredWay_(rhs.preferredWay_),
  currentPassNumber_(rhs.currentPassNumber_),
  maximumWhich_(rhs.maximumWhich_),
  whichGenerator_(NULL),
  maximumStatistics_(0),
  statistics_(NULL),
  maximumDepthActual_(0),
  numberDJFixed_(0.0),
  probingInfo_(NULL),
  numberFixedAtRoot_(rhs.numberFixedAtRoot_),
  numberFixedNow_(rhs.numberFixedNow_),
  stoppedOnGap_(rhs.stoppedOnGap_),
  eventHappened_(rhs.eventHappened_),
  numberLongStrong_(rhs.numberLongStrong_),
  numberOldActiveCuts_(rhs.numberOldActiveCuts_),
  numberNewCuts_(rhs.numberNewCuts_),
  sizeMiniTree_(rhs.sizeMiniTree_),
  searchStrategy_(rhs.searchStrategy_),
  numberStrongIterations_(rhs.numberStrongIterations_),
  resolveAfterTakeOffCuts_(rhs.resolveAfterTakeOffCuts_),
#if NEW_UPDATE_OBJECT>1
  numberUpdateItems_(rhs.numberUpdateItems_),
  maximumNumberUpdateItems_(rhs.maximumNumberUpdateItems_),
  updateItems_(NULL),
#endif
  numberThreads_(rhs.numberThreads_),
  threadMode_(rhs.threadMode_)
{
  memcpy(intParam_,rhs.intParam_,sizeof(intParam_));
  memcpy(dblParam_,rhs.dblParam_,sizeof(dblParam_));
  strongInfo_[0]=rhs.strongInfo_[0];
  strongInfo_[1]=rhs.strongInfo_[1];
  strongInfo_[2]=rhs.strongInfo_[2];
  solverCharacteristics_ = NULL;
  if (rhs.emptyWarmStart_) emptyWarmStart_ = rhs.emptyWarmStart_->clone() ;
  if (defaultHandler_) {
    handler_ = new CoinMessageHandler();
    handler_->setLogLevel(2);
  } else {
    handler_ = rhs.handler_;
  }
  messageHandler()->setLogLevel(rhs.messageHandler()->logLevel());
  numberCutGenerators_ = rhs.numberCutGenerators_;
  if (numberCutGenerators_) {
    generator_ = new CbcCutGenerator * [numberCutGenerators_];
    virginGenerator_ = new CbcCutGenerator * [numberCutGenerators_];
    int i;
    for (i=0;i<numberCutGenerators_;i++) {
      generator_[i]=new CbcCutGenerator(*rhs.generator_[i]);
      virginGenerator_[i]=new CbcCutGenerator(*rhs.virginGenerator_[i]);
    }
  } else {
    generator_=NULL;
    virginGenerator_=NULL;
  }
  if (!noTree)
    globalCuts_ = rhs.globalCuts_;
  numberHeuristics_ = rhs.numberHeuristics_;
  if (numberHeuristics_) {
    heuristic_ = new CbcHeuristic * [numberHeuristics_];
    int i;
    for (i=0;i<numberHeuristics_;i++) {
      heuristic_[i]=rhs.heuristic_[i]->clone();
    }
  } else {
    heuristic_=NULL;
  }
  lastHeuristic_ = NULL;
  if (rhs.eventHandler_)
    { eventHandler_ = rhs.eventHandler_->clone() ; }
  else
  { eventHandler_ = NULL ; }
  ownObjects_ = rhs.ownObjects_;
  if (ownObjects_) {
    numberObjects_=rhs.numberObjects_;
    if (numberObjects_) {
      object_ = new OsiObject * [numberObjects_];
      int i;
      for (i=0;i<numberObjects_;i++) {
        object_[i]=(rhs.object_[i])->clone();
        CbcObject * obj = dynamic_cast <CbcObject *>(object_[i]) ;
        // Could be OsiObjects
        if (obj)
          obj->setModel(this);
      }
    } else {
      object_=NULL;
    }
  } else {
    // assume will be redone
    numberObjects_=0;
    object_=NULL;
  }
  if (rhs.referenceSolver_)
    referenceSolver_ = rhs.referenceSolver_->clone();
  else
    referenceSolver_=NULL;
  if (!noTree||!rhs.continuousSolver_)
    solver_ = rhs.solver_->clone();
  else
    solver_ = rhs.continuousSolver_->clone();
  if (rhs.originalColumns_) {
    int numberColumns = solver_->getNumCols();
    originalColumns_= new int [numberColumns];
    memcpy(originalColumns_,rhs.originalColumns_,numberColumns*sizeof(int));
  } else {
    originalColumns_=NULL;
  }
#if NEW_UPDATE_OBJECT>1
  if (maximumNumberUpdateItems_) {
    updateItems_ = new CbcObjectUpdateData [maximumNumberUpdateItems_];
    for (int i=0;i<maximumNumberUpdateItems_;i++)
      updateItems_[i] = rhs.updateItems_[i];
  }
#endif
  if (maximumWhich_&&rhs.whichGenerator_)
    whichGenerator_ = CoinCopyOfArray(rhs.whichGenerator_,maximumWhich_);
  nodeCompare_=rhs.nodeCompare_->clone();
  problemFeasibility_=rhs.problemFeasibility_->clone();
  tree_= rhs.tree_->clone();
  if (rhs.branchingMethod_)
    branchingMethod_=rhs.branchingMethod_->clone();
  else
    branchingMethod_=NULL;
  if (rhs.cutModifier_)
    cutModifier_=rhs.cutModifier_->clone();
  else
    cutModifier_=NULL;
  cbcColLower_ = NULL;
  cbcColUpper_ = NULL;
  cbcRowLower_ = NULL;
  cbcRowUpper_ = NULL;
  cbcColSolution_ = NULL;
  cbcRowPrice_ = NULL;
  cbcReducedCost_ = NULL;
  cbcRowActivity_ = NULL;
  if (rhs.strategy_)
    strategy_=rhs.strategy_->clone();
  else
    strategy_=NULL;
  parentModel_=rhs.parentModel_;
  appData_=rhs.appData_;
  messages_ = rhs.messages_;
  ourSolver_ = true ;
  messageHandler()->setLogLevel(rhs.messageHandler()->logLevel());
  numberIntegers_=rhs.numberIntegers_;
  if (numberIntegers_) {
    integerVariable_ = new int [numberIntegers_];
    memcpy(integerVariable_,rhs.integerVariable_,numberIntegers_*sizeof(int));
    integerInfo_ = CoinCopyOfArray(rhs.integerInfo_,solver_->getNumCols());
  } else {
    integerVariable_ = NULL;
    integerInfo_=NULL;
  }
  if (rhs.hotstartSolution_) {
    int numberColumns = solver_->getNumCols();
    hotstartSolution_ = CoinCopyOfArray(rhs.hotstartSolution_,numberColumns);
    hotstartPriorities_ = CoinCopyOfArray(rhs.hotstartPriorities_,numberColumns);
  } else {
    hotstartSolution_ = NULL;
    hotstartPriorities_ =NULL;
  }
  if (rhs.bestSolution_&&!noTree) {
    int numberColumns = solver_->getNumCols();
    bestSolution_ = new double[numberColumns];
    memcpy(bestSolution_,rhs.bestSolution_,numberColumns*sizeof(double));
  } else {
    bestSolution_=NULL;
  }
  if (!noTree) {
    int numberColumns = solver_->getNumCols();
    currentSolution_ = CoinCopyOfArray(rhs.currentSolution_,numberColumns);
    continuousSolution_ = CoinCopyOfArray(rhs.continuousSolution_,numberColumns);
    usedInSolution_ = CoinCopyOfArray(rhs.usedInSolution_,numberColumns);
  } else {
    currentSolution_=NULL;
    continuousSolution_=NULL;
    usedInSolution_=NULL;
  }
  testSolution_=currentSolution_;
  numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
  maximumNumberCuts_=rhs.maximumNumberCuts_;
  phase_ = rhs.phase_;
  currentNumberCuts_=rhs.currentNumberCuts_;
  maximumDepth_= rhs.maximumDepth_;
  if (noTree) {
    bestObjective_ = COIN_DBL_MAX;
    numberSolutions_ =0;
    stateOfSearch_= 0;
    numberHeuristicSolutions_=0;
    numberNodes_=0;
    numberNodes2_=0;
    numberIterations_=0;
    status_=0;
    subTreeModel_=NULL;
    numberStoppedSubTrees_=0;
    continuousObjective_=COIN_DBL_MAX;
    originalContinuousObjective_=COIN_DBL_MAX;
    continuousInfeasibilities_=COIN_INT_MAX;
    maximumNumberCuts_=0;
    tree_->cleanTree(this,-COIN_DBL_MAX,bestPossibleObjective_);
    bestPossibleObjective_ = COIN_DBL_MAX;
  }
  // These are only used as temporary arrays so need not be filled
  if (maximumNumberCuts_) {
    addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
  } else {
    addedCuts_ = NULL;
  }
  bestSolutionBasis_ = rhs.bestSolutionBasis_;
  nextRowCut_ = NULL;
  currentNode_ = NULL;
  if (maximumDepth_)
    walkback_ = new CbcNodeInfo * [maximumDepth_];
  else
    walkback_ = NULL;
  synchronizeModel();
}
  
// Assignment operator 
CbcModel & 
CbcModel::operator=(const CbcModel& rhs)
{
  if (this!=&rhs) {
    if (ourSolver_) {
      delete solver_;
      solver_=NULL;
    }
    gutsOfDestructor();
    if (defaultHandler_)
    { delete handler_;
      handler_ = NULL; }
    defaultHandler_ = rhs.defaultHandler_;
    if (defaultHandler_)
    { handler_ = new CoinMessageHandler();
      handler_->setLogLevel(2); }
    else
    { handler_ = rhs.handler_; }
    messages_ = rhs.messages_;
    messageHandler()->setLogLevel(rhs.messageHandler()->logLevel());
    if (rhs.solver_)
    { solver_ = rhs.solver_->clone() ; }
    else
    { solver_ = 0 ; }
    ourSolver_ = true ;
    delete continuousSolver_ ;
    if (rhs.continuousSolver_)
    { continuousSolver_ = rhs.continuousSolver_->clone() ; }
    else
    { continuousSolver_ = 0 ; }
    delete referenceSolver_;
    if (rhs.referenceSolver_)
    { referenceSolver_ = rhs.referenceSolver_->clone() ; }
    else
    { referenceSolver_ = NULL ; }

    delete emptyWarmStart_ ;
    if (rhs.emptyWarmStart_)
    { emptyWarmStart_ = rhs.emptyWarmStart_->clone() ; }
    else
    { emptyWarmStart_ = 0 ; }

    bestObjective_ = rhs.bestObjective_;
    bestPossibleObjective_=rhs.bestPossibleObjective_;
    sumChangeObjective1_=rhs.sumChangeObjective1_;
    sumChangeObjective2_=rhs.sumChangeObjective2_;
    delete [] bestSolution_;
    if (rhs.bestSolution_) {
      int numberColumns = rhs.getNumCols();
      bestSolution_ = new double[numberColumns];
      memcpy(bestSolution_,rhs.bestSolution_,numberColumns*sizeof(double));
    } else {
      bestSolution_=NULL;
    }
    int numberColumns = rhs.getNumCols();
    currentSolution_ = CoinCopyOfArray(rhs.currentSolution_,numberColumns);
    continuousSolution_ = CoinCopyOfArray(rhs.continuousSolution_,numberColumns);
    usedInSolution_ = CoinCopyOfArray(rhs.usedInSolution_,numberColumns);
    testSolution_=currentSolution_;
    minimumDrop_ = rhs.minimumDrop_;
    numberSolutions_=rhs.numberSolutions_;
    stateOfSearch_= rhs.stateOfSearch_;
    numberHeuristicSolutions_=rhs.numberHeuristicSolutions_;
    numberNodes_ = rhs.numberNodes_;
    numberNodes2_ = rhs.numberNodes2_;
    numberIterations_ = rhs.numberIterations_;
    status_ = rhs.status_;
    secondaryStatus_ = rhs.secondaryStatus_;
    specialOptions_ = rhs.specialOptions_;
    subTreeModel_ = rhs.subTreeModel_;
    numberStoppedSubTrees_ = rhs.numberStoppedSubTrees_;
    mutex_ = NULL;
    presolve_ = rhs.presolve_;
    numberStrong_ = rhs.numberStrong_;
    numberBeforeTrust_ = rhs.numberBeforeTrust_;
    numberPenalties_ = rhs.numberPenalties_;
    penaltyScaleFactor_ = rhs.penaltyScaleFactor_;
    numberAnalyzeIterations_ = rhs.numberAnalyzeIterations_;
    delete [] analyzeResults_;
    analyzeResults_ = NULL;
    numberInfeasibleNodes_ = rhs.numberInfeasibleNodes_;
    problemType_ = rhs.problemType_;
    printFrequency_ = rhs.printFrequency_;
    howOftenGlobalScan_=rhs.howOftenGlobalScan_;
    numberGlobalViolations_=rhs.numberGlobalViolations_;
    continuousObjective_=rhs.continuousObjective_;
    originalContinuousObjective_ = rhs.originalContinuousObjective_;
    continuousInfeasibilities_ = rhs.continuousInfeasibilities_;
    maximumCutPassesAtRoot_ = rhs.maximumCutPassesAtRoot_;
    maximumCutPasses_ = rhs.maximumCutPasses_;
    preferredWay_ = rhs.preferredWay_;
    currentPassNumber_ = rhs.currentPassNumber_;
    memcpy(intParam_,rhs.intParam_,sizeof(intParam_));
    memcpy(dblParam_,rhs.dblParam_,sizeof(dblParam_));
    globalCuts_ = rhs.globalCuts_;
    int i;
    for (i=0;i<numberCutGenerators_;i++) {
      delete generator_[i];
      delete virginGenerator_[i];
    }
    delete [] generator_;
    delete [] virginGenerator_;
    delete [] heuristic_;
    maximumWhich_ = rhs.maximumWhich_;
    delete [] whichGenerator_;
    whichGenerator_ = NULL;
    if (maximumWhich_&&rhs.whichGenerator_)
      whichGenerator_ = CoinCopyOfArray(rhs.whichGenerator_,maximumWhich_);
    for (i=0;i<maximumStatistics_;i++)
      delete statistics_[i];
    delete [] statistics_;
    maximumStatistics_ = 0;
    statistics_ = NULL;
    delete probingInfo_;
    probingInfo_=NULL;
    numberFixedAtRoot_ = rhs.numberFixedAtRoot_;
    numberFixedNow_ = rhs.numberFixedNow_;
    stoppedOnGap_ = rhs.stoppedOnGap_;
    eventHappened_ = rhs.eventHappened_;
    numberLongStrong_ = rhs.numberLongStrong_;
    numberOldActiveCuts_ = rhs.numberOldActiveCuts_;
    numberNewCuts_ = rhs.numberNewCuts_;
    resolveAfterTakeOffCuts_=rhs.resolveAfterTakeOffCuts_;
#if NEW_UPDATE_OBJECT>1
    numberUpdateItems_ = rhs.numberUpdateItems_;
    maximumNumberUpdateItems_ = rhs.maximumNumberUpdateItems_;
    delete [] updateItems_;
    if (maximumNumberUpdateItems_) {
      updateItems_ = new CbcObjectUpdateData [maximumNumberUpdateItems_];
      for (i=0;i<maximumNumberUpdateItems_;i++)
        updateItems_[i] = rhs.updateItems_[i];
    } else {
      updateItems_ = NULL;
    }
#endif
    numberThreads_ = rhs.numberThreads_;
    threadMode_ = rhs.threadMode_;
    sizeMiniTree_ = rhs.sizeMiniTree_;
    searchStrategy_ = rhs.searchStrategy_;
    numberStrongIterations_ = rhs.numberStrongIterations_;
    strongInfo_[0]=rhs.strongInfo_[0];
    strongInfo_[1]=rhs.strongInfo_[1];
    strongInfo_[2]=rhs.strongInfo_[2];
    solverCharacteristics_ = NULL;
    lastHeuristic_ = NULL;
    numberCutGenerators_ = rhs.numberCutGenerators_;
    if (numberCutGenerators_) {
      generator_ = new CbcCutGenerator * [numberCutGenerators_];
      virginGenerator_ = new CbcCutGenerator * [numberCutGenerators_];
      int i;
      for (i=0;i<numberCutGenerators_;i++) {
        generator_[i]=new CbcCutGenerator(*rhs.generator_[i]);
        virginGenerator_[i]=new CbcCutGenerator(*rhs.virginGenerator_[i]);
      }
    } else {
      generator_=NULL;
      virginGenerator_=NULL;
    }
    numberHeuristics_ = rhs.numberHeuristics_;
    if (numberHeuristics_) {
      heuristic_ = new CbcHeuristic * [numberHeuristics_];
      memcpy(heuristic_,rhs.heuristic_,
             numberHeuristics_*sizeof(CbcHeuristic *));
    } else {
      heuristic_=NULL;
    }
    lastHeuristic_ = NULL;
    if (eventHandler_)
      delete eventHandler_ ;
    if (rhs.eventHandler_)
      { eventHandler_ = rhs.eventHandler_->clone() ; }
    else
    { eventHandler_ = NULL ; }
    if (ownObjects_) {
      for (i=0;i<numberObjects_;i++)
        delete object_[i];
      delete [] object_;
      numberObjects_=rhs.numberObjects_;
      if (numberObjects_) {
        object_ = new OsiObject * [numberObjects_];
        int i;
        for (i=0;i<numberObjects_;i++) 
          object_[i]=(rhs.object_[i])->clone();
      } else {
        object_=NULL;
    }
    } else {
      // assume will be redone
      numberObjects_=0;
      object_=NULL;
    }
    delete [] originalColumns_;
    if (rhs.originalColumns_) {
      int numberColumns = rhs.getNumCols();
      originalColumns_= new int [numberColumns];
      memcpy(originalColumns_,rhs.originalColumns_,numberColumns*sizeof(int));
    } else {
      originalColumns_=NULL;
    }
    nodeCompare_=rhs.nodeCompare_->clone();
    problemFeasibility_=rhs.problemFeasibility_->clone();
    delete tree_;
    tree_= rhs.tree_->clone();
    if (rhs.branchingMethod_)
      branchingMethod_=rhs.branchingMethod_->clone();
    else
      branchingMethod_=NULL;
    if (rhs.cutModifier_)
      cutModifier_=rhs.cutModifier_->clone();
    else
      cutModifier_=NULL;
    delete strategy_;
    if (rhs.strategy_)
      strategy_=rhs.strategy_->clone();
    else
      strategy_=NULL;
    parentModel_=rhs.parentModel_;
    appData_=rhs.appData_;

    delete [] integerVariable_;
    numberIntegers_=rhs.numberIntegers_;
    if (numberIntegers_) {
      integerVariable_ = new int [numberIntegers_];
      memcpy(integerVariable_,rhs.integerVariable_,
             numberIntegers_*sizeof(int));
      integerInfo_ = CoinCopyOfArray(rhs.integerInfo_,rhs.getNumCols());
    } else {
      integerVariable_ = NULL;
      integerInfo_=NULL;
    }
    if (rhs.hotstartSolution_) {
      int numberColumns = solver_->getNumCols();
      hotstartSolution_ = CoinCopyOfArray(rhs.hotstartSolution_,numberColumns);
      hotstartPriorities_ = CoinCopyOfArray(rhs.hotstartPriorities_,numberColumns);
    } else {
      hotstartSolution_ = NULL;
      hotstartPriorities_ =NULL;
    }
    numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
    maximumNumberCuts_=rhs.maximumNumberCuts_;
    phase_ = rhs.phase_;
    currentNumberCuts_=rhs.currentNumberCuts_;
    maximumDepth_= rhs.maximumDepth_;
    delete [] addedCuts_;
    delete [] walkback_;
    // These are only used as temporary arrays so need not be filled
    if (maximumNumberCuts_) {
      addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
    } else {
      addedCuts_ = NULL;
    }
    bestSolutionBasis_ = rhs.bestSolutionBasis_;
    nextRowCut_ = NULL;
    currentNode_ = NULL;
    if (maximumDepth_)
      walkback_ = new CbcNodeInfo * [maximumDepth_];
    else
      walkback_ = NULL;
    synchronizeModel();
    cbcColLower_ = NULL;
    cbcColUpper_ = NULL;
    cbcRowLower_ = NULL;
    cbcRowUpper_ = NULL;
    cbcColSolution_ = NULL;
    cbcRowPrice_ = NULL;
    cbcReducedCost_ = NULL;
    cbcRowActivity_ = NULL;
  }
  return *this;
}
// Destructor 
CbcModel::~CbcModel ()
{
  if (defaultHandler_) {
    delete handler_;
    handler_ = NULL;
  }
  delete tree_;
  tree_=NULL;
  if (ourSolver_) {
    delete solver_;
    solver_ = NULL;
  }
  gutsOfDestructor();
  delete eventHandler_ ;
  eventHandler_ = NULL ;
}
// Clears out as much as possible (except solver)
void 
CbcModel::gutsOfDestructor()
{
  delete referenceSolver_;
  referenceSolver_=NULL;
  int i;
  for (i=0;i<numberCutGenerators_;i++) {
    delete generator_[i];
    delete virginGenerator_[i];
  }
  delete [] generator_;
  delete [] virginGenerator_;
  generator_=NULL;
  virginGenerator_=NULL;
  for (i=0;i<numberHeuristics_;i++)
    delete heuristic_[i];
  delete [] heuristic_;
  heuristic_=NULL;
  delete nodeCompare_;
  nodeCompare_=NULL;
  delete problemFeasibility_;
  problemFeasibility_=NULL;
  delete [] originalColumns_;
  originalColumns_=NULL;
  delete strategy_;
#if NEW_UPDATE_OBJECT>1
  delete [] updateItems_;
  updateItems_=NULL;
  numberUpdateItems_=0;
  maximumNumberUpdateItems_=0;
#endif
  gutsOfDestructor2();
}
// Clears out enough to reset CbcModel
void 
CbcModel::gutsOfDestructor2()
{
  delete [] integerInfo_;
  integerInfo_=NULL;
  delete [] integerVariable_;
  integerVariable_=NULL;
  int i;
  if (ownObjects_) {
    for (i=0;i<numberObjects_;i++)
      delete object_[i];
    delete [] object_;
  }
  ownObjects_=true;
  object_=NULL;
  numberIntegers_=0;
  numberObjects_=0;
  // Below here is whatever consensus is
  ourSolver_=true;
  delete branchingMethod_;
  branchingMethod_=NULL;
  delete cutModifier_;
  cutModifier_=NULL;
  resetModel();
}
// Clears out enough to reset CbcModel
void 
CbcModel::resetModel()
{
  delete emptyWarmStart_ ;
  emptyWarmStart_ =NULL;
  delete continuousSolver_;
  continuousSolver_=NULL;
  delete [] bestSolution_;
  bestSolution_=NULL;
  delete [] currentSolution_;
  currentSolution_=NULL;
  delete [] continuousSolution_;
  continuousSolution_=NULL;
  solverCharacteristics_=NULL;
  delete [] usedInSolution_;
  usedInSolution_ = NULL;
  testSolution_=NULL;
  lastHeuristic_ = NULL;
  delete [] addedCuts_;
  addedCuts_=NULL;
  nextRowCut_ = NULL;
  currentNode_ = NULL;
  delete [] walkback_;
  walkback_=NULL;
  delete [] whichGenerator_;
  whichGenerator_ = NULL;
  for (int i=0;i<maximumStatistics_;i++)
    delete statistics_[i];
  delete [] statistics_;
  statistics_=NULL;
  maximumDepthActual_ = 0;
  numberDJFixed_ =0.0;
  delete probingInfo_;
  probingInfo_ = NULL;
  maximumStatistics_=0;
  delete [] analyzeResults_;
  analyzeResults_=NULL;
  bestObjective_=COIN_DBL_MAX;
  bestPossibleObjective_=COIN_DBL_MAX;
  sumChangeObjective1_=0.0;
  sumChangeObjective2_=0.0;
  numberSolutions_=0;
  stateOfSearch_=0;
  delete [] hotstartSolution_;
  hotstartSolution_=NULL;
  delete [] hotstartPriorities_;
  hotstartPriorities_=NULL;
  numberHeuristicSolutions_=0;
  numberNodes_=0;
  numberNodes2_=0;
  numberIterations_=0;
  status_=-1;
  secondaryStatus_=-1;
  maximumNumberCuts_=0;
  phase_=0;
  currentNumberCuts_=0;
  maximumDepth_=0;
  nextRowCut_=NULL;
  currentNode_=NULL;
  // clear out tree
  if (tree_&&tree_->size())
    tree_->cleanTree(this, -1.0e100,bestPossibleObjective_) ;
  subTreeModel_=NULL;
  numberStoppedSubTrees_=0;
  numberInfeasibleNodes_=0;
  numberGlobalViolations_=0;
  continuousObjective_=0.0;
  originalContinuousObjective_=0.0;
  continuousInfeasibilities_=0;
  numberFixedAtRoot_=0;
  numberFixedNow_=0;
  stoppedOnGap_=false;
  eventHappened_=false;
  numberLongStrong_=0;
  numberOldActiveCuts_=0;
  numberNewCuts_=0;
  searchStrategy_=-1;
  numberStrongIterations_=0;
  // Parameters which need to be reset
  setCutoff(COIN_DBL_MAX);
  dblParam_[CbcCutoffIncrement] = 1e-5;
  dblParam_[CbcCurrentCutoff] = 1.0e100;
  dblParam_[CbcCurrentObjectiveValue] = 1.0e100;
  dblParam_[CbcCurrentMinimizationObjectiveValue] = 1.0e100;
}
// Move status, nodes etc etc across
void 
CbcModel::moveInfo(const CbcModel & rhs)
{
  bestObjective_ = rhs.bestObjective_;
  bestPossibleObjective_=rhs.bestPossibleObjective_;
  numberSolutions_=rhs.numberSolutions_;
  numberHeuristicSolutions_=rhs.numberHeuristicSolutions_;
  numberNodes_ = rhs.numberNodes_;
  numberNodes2_ = rhs.numberNodes2_;
  numberIterations_ = rhs.numberIterations_;
  status_ = rhs.status_;
  secondaryStatus_ = rhs.secondaryStatus_;
  numberStoppedSubTrees_ = rhs.numberStoppedSubTrees_;
  numberInfeasibleNodes_ = rhs.numberInfeasibleNodes_;
  continuousObjective_=rhs.continuousObjective_;
  originalContinuousObjective_ = rhs.originalContinuousObjective_;
  continuousInfeasibilities_ = rhs.continuousInfeasibilities_;
  numberFixedAtRoot_ = rhs.numberFixedAtRoot_;
  numberFixedNow_ = rhs.numberFixedNow_;
  stoppedOnGap_ = rhs.stoppedOnGap_;
  eventHappened_ = rhs.eventHappened_;
  numberLongStrong_ = rhs.numberLongStrong_;
  numberStrongIterations_ = rhs.numberStrongIterations_;
  strongInfo_[0]=rhs.strongInfo_[0];
  strongInfo_[1]=rhs.strongInfo_[1];
  strongInfo_[2]=rhs.strongInfo_[2];
  numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
  maximumDepth_= rhs.maximumDepth_;
}
// Save a copy of the current solver so can be reset to
void 
CbcModel::saveReferenceSolver()
{
  delete referenceSolver_;
  referenceSolver_= solver_->clone();
}

// Uses a copy of reference solver to be current solver
void 
CbcModel::resetToReferenceSolver()
{
  delete solver_;
  solver_ = referenceSolver_->clone();
  // clear many things
  gutsOfDestructor2();
  // Reset cutoff
  // Solvers know about direction
  double direction = solver_->getObjSense();
  double value;
  solver_->getDblParam(OsiDualObjectiveLimit,value); 
  setCutoff(value*direction);
}

// Are there a numerical difficulties?
bool 
CbcModel::isAbandoned() const
{
  return status_ == 2;
}
// Is optimality proven?
bool 
CbcModel::isProvenOptimal() const
{
  if (!status_ && bestObjective_<1.0e30)
    return true;
  else
    return false;
}
// Is  infeasiblity proven (or none better than cutoff)?
bool 
CbcModel::isProvenInfeasible() const
{
  if (!status_ && bestObjective_>=1.0e30)
    return true;
  else
    return false;
}
// Was continuous solution unbounded
bool 
CbcModel::isContinuousUnbounded() const
{
  if (!status_ && secondaryStatus_==7)
    return true;
  else
    return false;
}
// Was continuous solution unbounded
bool 
CbcModel::isProvenDualInfeasible() const
{
  if (!status_ && secondaryStatus_==7)
    return true;
  else
    return false;
}
// Node limit reached?
bool 
CbcModel::isNodeLimitReached() const
{
  return numberNodes_ >= intParam_[CbcMaxNumNode];
}
// Time limit reached?
bool 
CbcModel::isSecondsLimitReached() const
{
  if (status_==1&&secondaryStatus_==4)
    return true;
  else
    return false;
}
// Solution limit reached?
bool 
CbcModel::isSolutionLimitReached() const
{
  return numberSolutions_ >= intParam_[CbcMaxNumSol];
}
// Set language
void 
CbcModel::newLanguage(CoinMessages::Language language)
{
  messages_ = CbcMessage(language);
}
void 
CbcModel::setNumberStrong(int number)
{
  if (number<0)
    numberStrong_=0;
   else
    numberStrong_=number;
}
void 
CbcModel::setNumberBeforeTrust(int number)
{
  if (number<-1) {
    numberBeforeTrust_=0;
  } else {
    numberBeforeTrust_=number;
    //numberStrong_ = CoinMax(numberStrong_,1);
  }
}
void 
CbcModel::setNumberPenalties(int number)
{
  if (number<=0) {
    numberPenalties_=0;
  } else {
    numberPenalties_=number;
  }
}
void 
CbcModel::setPenaltyScaleFactor(double value)
{
  if (value<=0) {
    penaltyScaleFactor_=3.0;
  } else {
    penaltyScaleFactor_=value;
  }
}
void 
CbcModel::setHowOftenGlobalScan(int number)
{
  if (number<-1)
    howOftenGlobalScan_=0;
   else
    howOftenGlobalScan_=number;
}

// Add one generator
void 
CbcModel::addCutGenerator(CglCutGenerator * generator,
                          int howOften, const char * name,
                          bool normal, bool atSolution,
                          bool whenInfeasible,int howOftenInSub,
                          int whatDepth, int whatDepthInSub)
{
  CbcCutGenerator ** temp = generator_;
  generator_ = new CbcCutGenerator * [numberCutGenerators_+1];
  memcpy(generator_,temp,numberCutGenerators_*sizeof(CbcCutGenerator *));
  delete[] temp ;
  generator_[numberCutGenerators_]= 
    new CbcCutGenerator(this,generator, howOften, name,
                        normal,atSolution,whenInfeasible,howOftenInSub,
                        whatDepth, whatDepthInSub);
  // and before any cahnges
  temp = virginGenerator_;
  virginGenerator_ = new CbcCutGenerator * [numberCutGenerators_+1];
  memcpy(virginGenerator_,temp,numberCutGenerators_*sizeof(CbcCutGenerator *));
  delete[] temp ;
  virginGenerator_[numberCutGenerators_++]= 
    new CbcCutGenerator(this,generator, howOften, name,
                        normal,atSolution,whenInfeasible,howOftenInSub,
                        whatDepth, whatDepthInSub);
                                                          
}
// Add one heuristic
void 
CbcModel::addHeuristic(CbcHeuristic * generator, const char *name)
{
  CbcHeuristic ** temp = heuristic_;
  heuristic_ = new CbcHeuristic * [numberHeuristics_+1];
  memcpy(heuristic_,temp,numberHeuristics_*sizeof(CbcHeuristic *));
  delete [] temp;
  heuristic_[numberHeuristics_]=generator->clone();
  if (name)
  { heuristic_[numberHeuristics_]->setHeuristicName(name) ; }
  numberHeuristics_++ ;
}

/*
  The last subproblem handled by the solver is not necessarily related to the
  one being recreated, so the first action is to remove all cuts from the
  constraint system.  Next, traverse the tree from node to the root to
  determine the basis size required for this subproblem and create an empty
  basis with the right capacity.  Finally, traverse the tree from root to
  node, adjusting bounds in the constraint system, adjusting the basis, and
  collecting the cuts that must be added to the constraint system.
  applyToModel does the heavy lifting.

  addCuts1 is used in contexts where all that's desired is the list of cuts:
  the node is already fathomed, and we're collecting cuts so that we can
  adjust reference counts as we prune nodes. Arguably the two functions
  should be separated. The culprit is applyToModel, which performs cut
  collection and model adjustment.

  Certainly in the contexts where all we need is a list of cuts, there's no
  point in passing in a valid basis --- an empty basis will do just fine.
*/
void CbcModel::addCuts1 (CbcNode * node, CoinWarmStartBasis *&lastws)
{ int i;
  int nNode=0;
  int numberColumns = getNumCols();
  CbcNodeInfo * nodeInfo = node->nodeInfo();

/*
  Remove all cuts from the constraint system.
  (original comment includes ``see note below for later efficiency'', but
  the reference isn't clear to me).
*/
  int currentNumberCuts = solver_->getNumRows()-numberRowsAtContinuous_;
  int *which = new int[currentNumberCuts];
  for (i = 0 ; i < currentNumberCuts ; i++)
    which[i] = i+numberRowsAtContinuous_;
  solver_->deleteRows(currentNumberCuts,which);
  delete [] which;
/*
  Accumulate the path from node to the root in walkback_, and accumulate a
  cut count in currentNumberCuts.

  original comment: when working then just unwind until where new node joins
  old node (for cuts?)
*/
  currentNumberCuts = 0;
  while (nodeInfo) {
    //printf("nNode = %d, nodeInfo = %x\n",nNode,nodeInfo);
    walkback_[nNode++]=nodeInfo;
    currentNumberCuts += nodeInfo->numberCuts() ;
    nodeInfo = nodeInfo->parent() ;
    if (nNode==maximumDepth_) {
      maximumDepth_ *= 2;
      CbcNodeInfo ** temp = new CbcNodeInfo * [maximumDepth_];
      for (i=0;i<nNode;i++) 
        temp[i] = walkback_[i];
      delete [] walkback_;
      walkback_ = temp;
    }
  }
/*
  Create an empty basis with sufficient capacity for the constraint system
  we'll construct: original system plus cuts. Make sure we have capacity to
  record those cuts in addedCuts_.

  The method of adjusting the basis at a FullNodeInfo object (the root, for
  example) is to use a copy constructor to duplicate the basis held in the
  nodeInfo, then resize it and return the new basis object. Guaranteed,
  lastws will point to a different basis when it returns. We pass in a basis
  because we need the parameter to return the allocated basis, and it's an
  easy way to pass in the size. But we take a hit for memory allocation.
*/
  currentNumberCuts_=currentNumberCuts;
  if (currentNumberCuts > maximumNumberCuts_) {
    maximumNumberCuts_ = currentNumberCuts;
    delete [] addedCuts_;
    addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
  }
  lastws->setSize(numberColumns,numberRowsAtContinuous_+currentNumberCuts);
/*
  This last bit of code traverses the path collected in walkback_ from the
  root back to node. At the end of the loop,
   * lastws will be an appropriate basis for node;
   * variable bounds in the constraint system will be set to be correct for
     node; and
   * addedCuts_ will be set to a list of cuts that need to be added to the
     constraint system at node.
  applyToModel does all the heavy lifting.
*/
  currentNumberCuts=0;
  while (nNode) {
    --nNode;
    walkback_[nNode]->applyToModel(this,lastws,addedCuts_,currentNumberCuts);
  }
}

/*
  adjustCuts might be a better name: If the node is feasible, we sift through
  the cuts collected by addCuts1, add the ones that are tight and omit the
  ones that are loose. If the node is infeasible, we just adjust the
  reference counts to reflect that we're about to prune this node and its
  descendants.
*/
int CbcModel::addCuts (CbcNode *node, CoinWarmStartBasis *&lastws,bool canFix)
{
/*
  addCuts1 performs step 1 of restoring the subproblem at this node; see the
  comments there.
*/
  addCuts1(node,lastws);
  int i;
  int numberColumns = getNumCols();
  CbcNodeInfo * nodeInfo = node->nodeInfo();
  double cutoff = getCutoff() ;
  int currentNumberCuts=currentNumberCuts_;
  if (canFix) {
    bool feasible=true;
    const double *lower = solver_->getColLower() ;
    const double *upper = solver_->getColUpper() ;
    double * newLower = analyzeResults_;
    double * objLower = newLower+numberIntegers_;
    double * newUpper = objLower+numberIntegers_;
    double * objUpper = newUpper+numberIntegers_;
    int n=0;
    for (i=0;i<numberIntegers_;i++) {
      int iColumn = integerVariable_[i];
      bool changed=false;
      double lo = 0.0;
      double up = 0.0;
      if (objLower[i]>cutoff) {
        lo = lower[iColumn];
        up = upper[iColumn];
        if (lo<newLower[i]) {
          lo = newLower[i];
          solver_->setColLower(iColumn,lo);
          changed=true;
          n++;
        }
        if (objUpper[i]>cutoff) {
          if (up>newUpper[i]) {
            up = newUpper[i];
            solver_->setColUpper(iColumn,up);
            changed=true;
            n++;
          }
        }
      } else if (objUpper[i]>cutoff) {
        lo = lower[iColumn];
        up = upper[iColumn];
        if (up>newUpper[i]) {
          up = newUpper[i];
          solver_->setColUpper(iColumn,up);
          changed=true;
          n++;
        }
      }
      if (changed&&lo>up) {
        feasible=false;
        break;
      }
    }
    if (!feasible) {
      printf("analysis says node infeas\n");
      cutoff=-COIN_DBL_MAX;
    }
  }
/*
  If the node can't be fathomed by bound, reinstall tight cuts in the
  constraint system. Even if there are no cuts, we'll want to set the
  reconstructed basis in the solver.
*/
  if (node->objectiveValue() < cutoff||numberThreads_)
  { 
#   ifdef CBC_CHECK_BASIS
    printf("addCuts: expanded basis; rows %d+%d\n",
           numberRowsAtContinuous_,currentNumberCuts);
    lastws->print();
#   endif
/*
  Adjust the basis and constraint system so that we retain only active cuts.
  There are three steps:
    1) Scan the basis. Sort the cuts into effective cuts to be kept and
       loose cuts to be dropped.
    2) Drop the loose cuts and resize the basis to fit.
    3) Install the tight cuts in the constraint system (applyRowCuts) and
       and install the basis (setWarmStart).
  Use of compressRows conveys we're compressing the basis and not just
  tweaking the artificialStatus_ array.
*/
    if (currentNumberCuts > 0) {
      int numberToAdd = 0;
      const OsiRowCut **addCuts;
      int numberToDrop = 0 ;
      int *cutsToDrop ;
      addCuts = new const OsiRowCut* [currentNumberCuts];
      cutsToDrop = new int[currentNumberCuts] ;
      assert (currentNumberCuts+numberRowsAtContinuous_<=lastws->getNumArtificial());
      for (i=0;i<currentNumberCuts;i++) {
        CoinWarmStartBasis::Status status = 
          lastws->getArtifStatus(i+numberRowsAtContinuous_);
        if (addedCuts_[i] &&
            (status != CoinWarmStartBasis::basic ||
             addedCuts_[i]->effectiveness()==COIN_DBL_MAX)) {
#         ifdef CHECK_CUT_COUNTS
          printf("Using cut %d %x as row %d\n",i,addedCuts_[i],
                 numberRowsAtContinuous_+numberToAdd);
#         endif
          addCuts[numberToAdd++] = new OsiRowCut(*addedCuts_[i]);
        } else {
#         ifdef CHECK_CUT_COUNTS
          printf("Dropping cut %d %x\n",i,addedCuts_[i]);
#         endif
          addedCuts_[i]=NULL;
          cutsToDrop[numberToDrop++] = numberRowsAtContinuous_+i ;
        }
      }
      int numberRowsNow=numberRowsAtContinuous_+numberToAdd;
      lastws->compressRows(numberToDrop,cutsToDrop) ;
      lastws->resize(numberRowsNow,numberColumns);
      solver_->applyRowCuts(numberToAdd,addCuts);
#     ifdef CBC_CHECK_BASIS
      printf("addCuts: stripped basis; rows %d + %d\n",
             numberRowsAtContinuous_,numberToAdd);
      lastws->print();
#     endif
      for (i=0;i<numberToAdd;i++)
        delete addCuts[i];
      delete [] addCuts;
      delete [] cutsToDrop ;
    }
/*
  Set the basis in the solver.
*/
    solver_->setWarmStart(lastws);
#if 0
    if ((numberNodes_%printFrequency_)==0) {
      printf("Objective %g, depth %d, unsatisfied %d\n",
             node->objectiveValue(),
             node->depth(),node->numberUnsatisfied());
    }
#endif
/*
  Clean up and we're out of here.
*/
    numberNodes_++;
    return 0;
  } 
/*
  This node has been fathomed by bound as we try to revive it out of the live
  set. Adjust the cut reference counts to reflect that we no longer need to
  explore the remaining branch arms, hence they will no longer reference any
  cuts. Cuts whose reference count falls to zero are deleted.  
*/
  else
  { int i;
    if (currentNumberCuts) {
      lockThread();
      int numberLeft = nodeInfo->numberBranchesLeft();
      for (i = 0 ; i < currentNumberCuts ; i++)
        { if (addedCuts_[i])
          { if (!addedCuts_[i]->decrement(numberLeft))
            { delete addedCuts_[i];
            addedCuts_[i] = NULL; } } }
      unlockThread();
    }
    return 1 ; }
}


/*
  Perform reduced cost fixing on integer variables.

  The variables in question are already nonbasic at bound. We're just nailing
  down the current situation.
*/

int CbcModel::reducedCostFix ()

{
  if(!solverCharacteristics_->reducedCostsAccurate())
    return 0; //NLP
  double cutoff = getCutoff() ;
  double direction = solver_->getObjSense() ;
  double gap = cutoff - solver_->getObjValue()*direction ;
  double tolerance;
  solver_->getDblParam(OsiDualTolerance,tolerance) ;
  if (gap<=0.0)
    return 0;
  gap += 100.0*tolerance;
  double integerTolerance = getDblParam(CbcIntegerTolerance) ;

  const double *lower = solver_->getColLower() ;
  const double *upper = solver_->getColUpper() ;
  const double *solution = solver_->getColSolution() ;
  const double *reducedCost = solver_->getReducedCost() ;

  int numberFixed = 0 ;

# ifdef COIN_HAS_CLP
  OsiClpSolverInterface * clpSolver 
    = dynamic_cast<OsiClpSolverInterface *> (solver_);
  ClpSimplex * clpSimplex=NULL;
  if (clpSolver) 
    clpSimplex = clpSolver->getModelPtr();
# endif
  for (int i = 0 ; i < numberIntegers_ ; i++)
  { int iColumn = integerVariable_[i] ;
    double djValue = direction*reducedCost[iColumn] ;
    if (upper[iColumn]-lower[iColumn] > integerTolerance)
    { if (solution[iColumn] < lower[iColumn]+integerTolerance && djValue > gap)
      { solver_->setColUpper(iColumn,lower[iColumn]) ;
#ifdef COIN_HAS_CLP
      // may just have been fixed before
      if (clpSimplex)
        assert(clpSimplex->getColumnStatus(iColumn)==ClpSimplex::atLowerBound||
               clpSimplex->getColumnStatus(iColumn)==ClpSimplex::isFixed);
#endif
      numberFixed++ ; }
      else
      if (solution[iColumn] > upper[iColumn]-integerTolerance && -djValue > gap)
      { solver_->setColLower(iColumn,upper[iColumn]) ;
#ifdef COIN_HAS_CLP
      // may just have been fixed before
      if (clpSimplex)
        assert(clpSimplex->getColumnStatus(iColumn)==ClpSimplex::atUpperBound||
               clpSimplex->getColumnStatus(iColumn)==ClpSimplex::isFixed);
#endif
      numberFixed++ ; } } }
  numberDJFixed_ += numberFixed;
  
  return numberFixed; }

// Collect coding to replace whichGenerator
void
CbcModel::resizeWhichGenerator(int numberNow, int numberAfter)
{
  if (numberAfter > maximumWhich_) {
    maximumWhich_ = CoinMax(maximumWhich_*2+100,numberAfter) ;
    int * temp = new int[2*maximumWhich_] ;
    memcpy(temp,whichGenerator_,numberNow*sizeof(int)) ;
    delete [] whichGenerator_ ;
    whichGenerator_ = temp ;
    memset(whichGenerator_+numberNow,0,(maximumWhich_-numberNow)*sizeof(int));
  }
}

/** Solve the model using cuts

  This version takes off redundant cuts from node.
  Returns true if feasible.

  \todo
  Why do I need to resolve the problem? What has been done between the last
  relaxation and calling solveWithCuts?

  If numberTries == 0 then user did not want any cuts.
*/

bool 
CbcModel::solveWithCuts (OsiCuts &cuts, int numberTries, CbcNode *node)
/*
  Parameters:
    numberTries: (i) the maximum number of iterations for this round of cut
                     generation; if negative then we don't mind if drop is tiny.
    
    cuts:       (o) all cuts generated in this round of cut generation

    node: (i)     So we can update dynamic pseudo costs
*/
                        

{
# ifdef COIN_HAS_CLP
  OsiClpSolverInterface * clpSolver 
    = dynamic_cast<OsiClpSolverInterface *> (solver_);
  int saveClpOptions=0;
  if (clpSolver) 
    saveClpOptions = clpSolver->specialOptions();
# endif
#ifdef CBC_THREAD
  CbcModel ** threadModel = NULL;
  pthread_t * threadId = NULL;
  pthread_cond_t condition_main;
  pthread_mutex_t condition_mutex;
  pthread_mutex_t * mutex2 = NULL;
  pthread_cond_t * condition2 = NULL;
  threadStruct * threadInfo = NULL;
  void * saveMutex = NULL;
  if (numberThreads_&&(threadMode_&2)!=0&&!numberNodes_) {
    threadId = new pthread_t [numberThreads_];
    pthread_cond_init(&condition_main,NULL);
    pthread_mutex_init(&condition_mutex,NULL);
    threadModel = new CbcModel * [numberThreads_];
    threadInfo = new threadStruct [numberThreads_+1];
    mutex2 = new pthread_mutex_t [numberThreads_];
    condition2 = new pthread_cond_t [numberThreads_];
    saveMutex = mutex_;
    for (int i=0;i<numberThreads_;i++) {
      pthread_mutex_init(mutex2+i,NULL);
      pthread_cond_init(condition2+i,NULL);
      threadId[i]=0;
      threadModel[i]=new CbcModel;
      threadModel[i]->generator_ = new CbcCutGenerator * [1];
      delete threadModel[i]->solver_;
      threadModel[i]->solver_=NULL;
      threadModel[i]->numberThreads_=numberThreads_;
      mutex_ = (void *) (threadInfo+i);
      threadInfo[i].thisModel=(CbcModel *) threadModel[i];
      threadInfo[i].baseModel=this;
      threadInfo[i].threadIdOfBase=pthread_self();
      threadInfo[i].mutex2=mutex2+i;
      threadInfo[i].condition2=condition2+i;
      threadInfo[i].returnCode=-1;
      pthread_create(threadId+i,NULL,doCutsThread,threadInfo+i);
    }
    // Do a partial one for base model
    threadInfo[numberThreads_].baseModel=this;
    mutex_ = (void *) (threadInfo+numberThreads_);
    threadInfo[numberThreads_].condition2=&condition_main;
    threadInfo[numberThreads_].mutex2=&condition_mutex;
  }
#endif
  bool feasible = true ;
  int lastNumberCuts = 0 ;
  double lastObjective = -1.0e100 ;
  int violated = 0 ;
  int numberRowsAtStart = solver_->getNumRows() ;
  //printf("solver had %d rows\n",numberRowsAtStart);
  int numberColumns = solver_->getNumCols() ;
  CoinBigIndex numberElementsAtStart = solver_->getNumElements();

  numberOldActiveCuts_ = numberRowsAtStart-numberRowsAtContinuous_ ;
  numberNewCuts_ = 0 ;

  bool onOptimalPath = false ;
  const OsiRowCutDebugger *debugger = NULL;
  if ((specialOptions_&1)!=0) {
    /*
      See OsiRowCutDebugger for details. In a nutshell, make sure that current
      variable values do not conflict with a known optimal solution. (Obviously
      this can be fooled when there are multiple solutions.)
    */
    debugger = solver_->getRowCutDebugger() ;
    if (debugger) 
      onOptimalPath = (debugger->onOptimalPath(*solver_)) ;
  }
  OsiCuts slackCuts;
/*
  Resolve the problem. If we've lost feasibility, might as well bail out right
  after the debug stuff. The resolve will also refresh cached copies of the
  solver solution (cbcColLower_, ...) held by CbcModel.
*/
  double objectiveValue = solver_->getObjValue()*solver_->getObjSense();
  if (node)
    objectiveValue= node->objectiveValue();
  int returnCode = resolve(node ? node->nodeInfo() : NULL,1);
#ifdef COIN_DEVELOP
  //if (!solver_->getIterationCount()&&solver_->isProvenOptimal())
  //printf("zero iterations on first solve of branch\n");
#endif
  if (node&&node->nodeInfo()&&!node->nodeInfo()->numberBranchesLeft())
    node->nodeInfo()->allBranchesGone(); // can clean up
  feasible = returnCode  != 0 ;
  if (returnCode<0)
    numberTries=0;
  if (problemFeasibility_->feasible(this,0)<0) {
    feasible=false; // pretend infeasible
  }
  
#if NEW_UPDATE_OBJECT==0
  // Update branching information if wanted
  if(node &&branchingMethod_)
    branchingMethod_->updateInformation(solver_,node);
#elif NEW_UPDATE_OBJECT<2
  // Update branching information if wanted
  if(node &&branchingMethod_) {
    OsiBranchingObject * bobj = node->modifiableBranchingObject();
    CbcBranchingObject * cbcobj = dynamic_cast<CbcBranchingObject *> (bobj);
    if (cbcobj) {
      CbcObject * object = cbcobj->object();
      CbcObjectUpdateData update = object->createUpdateInformation(solver_,node,cbcobj);
      object->updateInformation(update);
    } else {
      branchingMethod_->updateInformation(solver_,node);
    }
  }
#else
  // Update branching information if wanted
  if(node &&branchingMethod_) {
    OsiBranchingObject * bobj = node->modifiableBranchingObject();
    CbcBranchingObject * cbcobj = dynamic_cast<CbcBranchingObject *> (bobj);
    if (cbcobj&&cbcobj->object()) {
      CbcObject * object = cbcobj->object();
      CbcObjectUpdateData update = object->createUpdateInformation(solver_,node,cbcobj);
      // have to compute object number as not saved
      CbcSimpleInteger * simpleObject =
          dynamic_cast <CbcSimpleInteger *>(object) ;
      int iObject;
      int iColumn = simpleObject->columnNumber();
      for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
        simpleObject =
          dynamic_cast <CbcSimpleInteger *>(object_[iObject]) ;
        if (simpleObject->columnNumber()==iColumn)
          break;
      }
      assert (iObject<numberObjects_);
      update.objectNumber_ = iObject;
      addUpdateInformation(update);
    } else {
      OsiIntegerBranchingObject * obj = dynamic_cast<OsiIntegerBranchingObject *> (bobj);
      if (obj) {
        const OsiObject * object = obj->originalObject();
        // have to compute object number as not saved
        int iObject;
        int iColumn = object->columnNumber();
        for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
          if (object_[iObject]->columnNumber()==iColumn)
            break;
        }
        assert (iObject<numberObjects_);
        int branch = obj->firstBranch();
        if (obj->branchIndex()==2)
          branch = 1-branch;
        assert (branch==0||branch==1);
        double originalValue=node->objectiveValue();
        double objectiveValue = solver_->getObjValue()*solver_->getObjSense();
        double changeInObjective = CoinMax(0.0,objectiveValue-originalValue);
        int iStatus = (feasible) ? 0 : 0;
        double value = obj->value();
        if (branch)
          value = ceil(value)-value;
        else
          value = value -floor(value);
        branchingMethod_->chooseMethod()->updateInformation(iObject,branch,changeInObjective,
                                                            value,iStatus);
      }
    }
  }
#endif

#ifdef CBC_DEBUG
  if (feasible)
  { printf("Obj value %g (%s) %d rows\n",solver_->getObjValue(),
           (solver_->isProvenOptimal())?"proven":"unproven",
           solver_->getNumRows()) ; }
  
  else
  { printf("Infeasible %d rows\n",solver_->getNumRows()) ; }
#endif
  if ((specialOptions_&1)!=0) {
/*
  If the RowCutDebugger said we were compatible with the optimal solution,
  and now we're suddenly infeasible, we might be confused. Then again, we
  may have fathomed by bound, heading for a rediscovery of an optimal solution.
*/
    if (onOptimalPath && !solver_->isDualObjectiveLimitReached()) {
      if (!feasible) {
        solver_->writeMps("infeas");
        CoinWarmStartBasis *slack =
          dynamic_cast<CoinWarmStartBasis *>(solver_->getEmptyWarmStart()) ;
        solver_->setWarmStart(slack);
        delete slack ;
        solver_->setHintParam(OsiDoReducePrint,false,OsiHintDo,0) ;
        solver_->initialSolve();
      }
      assert(feasible) ;
    }
  }

  if (!feasible) {
    numberInfeasibleNodes_++;
# ifdef COIN_HAS_CLP
    if (clpSolver) 
    clpSolver->setSpecialOptions(saveClpOptions);
# endif
    return (false) ;
  }
  sumChangeObjective1_ += solver_->getObjValue()*solver_->getObjSense()
    - objectiveValue ;
  if ( getCurrentSeconds() > dblParam_[CbcMaximumSeconds] )
    numberTries=0; // exit
  //if ((numberNodes_%100)==0)
  //printf("XXa sum obj changed by %g\n",sumChangeObjective1_);
  objectiveValue = solver_->getObjValue()*solver_->getObjSense();
  // Return at once if numberTries zero
  if (!numberTries) {
    cuts=OsiCuts();
    numberNewCuts_=0;
# ifdef COIN_HAS_CLP
    if (clpSolver) 
    clpSolver->setSpecialOptions(saveClpOptions);
# endif
    return true;
  }
/*
  Do reduced cost fixing.
*/
  reducedCostFix() ;
/*
  Set up for at most numberTries rounds of cut generation. If numberTries is
  negative, we'll ignore the minimumDrop_ cutoff and keep generating cuts for
  the specified number of rounds.
*/
  double minimumDrop = minimumDrop_ ;
  if (numberTries<0)
  { numberTries = -numberTries ;
    minimumDrop = -1.0 ; }
/*
  Is it time to scan the cuts in order to remove redundant cuts? If so, set
  up to do it.
*/
# define SCANCUTS 100  
  int *countColumnCuts = NULL ;
  // Always accumulate row cut counts
  int * countRowCuts =new int[numberCutGenerators_+numberHeuristics_] ;
  memset(countRowCuts,0,
         (numberCutGenerators_+numberHeuristics_)*sizeof(int)) ;
  bool fullScan = false ;
  if ((numberNodes_%SCANCUTS) == 0)
  { fullScan = true ;
    countColumnCuts = new int[numberCutGenerators_+numberHeuristics_] ;
    memset(countColumnCuts,0,
           (numberCutGenerators_+numberHeuristics_)*sizeof(int)) ; }

  double direction = solver_->getObjSense() ;
  double startObjective = solver_->getObjValue()*direction ;

  currentPassNumber_ = 0 ;
  double primalTolerance = 1.0e-7 ;
  // We may need to keep going on
  bool keepGoing=false;
/*
  Begin cut generation loop. Cuts generated during each iteration are
  collected in theseCuts. The loop can be divided into four phases:
   1) Prep: Fix variables using reduced cost. In the first iteration only,
      consider scanning globalCuts_ and activating any applicable cuts.
   2) Cut Generation: Call each generator and heuristic registered in the
      generator_ and heuristic_ arrays. Newly generated global cuts are
      copied to globalCuts_ at this time.
   3) Cut Installation and Reoptimisation: Install column and row cuts in
      the solver. Copy row cuts to cuts (parameter). Reoptimise.
   4) Cut Purging: takeOffCuts() removes inactive cuts from the solver, and
      does the necessary bookkeeping in the model.
*/
  do
  { currentPassNumber_++ ;
    numberTries-- ;
    if (numberTries<0&&keepGoing) {
      // switch off all normal ones
      for (int i = 0;i<numberCutGenerators_;i++) {
        if (!generator_[i]->mustCallAgain())
          generator_[i]->setSwitchedOff(true);
      }
    }
    keepGoing=false;
    OsiCuts theseCuts ;
/*
  Scan previously generated global column and row cuts to see if any are
  useful.
*/
    int numberViolated=0;
    if (currentPassNumber_ == 1 && howOftenGlobalScan_ > 0 &&
        (numberNodes_%howOftenGlobalScan_) == 0)
    { int numberCuts = globalCuts_.sizeColCuts() ;
      int i;
      // possibly extend whichGenerator
      resizeWhichGenerator(numberViolated, numberViolated+numberCuts);
      for ( i = 0 ; i < numberCuts ; i++)
      { OsiColCut *thisCut = globalCuts_.colCutPtr(i) ;
        if (thisCut->violated(cbcColSolution_)>primalTolerance) {
          printf("Global cut added - violation %g\n",
                 thisCut->violated(cbcColSolution_)) ;
          whichGenerator_[numberViolated++]=-1;
#ifndef GLOBAL_CUTS_JUST_POINTERS
          theseCuts.insert(*thisCut) ;
#else
          theseCuts.insert(thisCut) ;
#endif
        }
      }
      numberCuts = globalCuts_.sizeRowCuts() ;
      // possibly extend whichGenerator
      resizeWhichGenerator(numberViolated, numberViolated+numberCuts);
      for ( i = 0;i<numberCuts;i++) {
        OsiRowCut * thisCut = globalCuts_.rowCutPtr(i) ;
        if (thisCut->violated(cbcColSolution_)>primalTolerance) {
          //printf("Global cut added - violation %g\n",
          // thisCut->violated(cbcColSolution_)) ;
          whichGenerator_[numberViolated++]=-1;
#ifndef GLOBAL_CUTS_JUST_POINTERS
          theseCuts.insert(*thisCut) ;
#else
          theseCuts.insert(thisCut) ;
#endif
        }
      }
      numberGlobalViolations_+=numberViolated;
    }
/*
  Generate new cuts (global and/or local) and/or apply heuristics.  If
  CglProbing is used, then it should be first as it can fix continuous
  variables.

  At present, CglProbing is the only case where generateCuts will return
  true. generateCuts actually modifies variable bounds in the solver when
  CglProbing indicates that it can fix a variable. Reoptimisation is required
  to take full advantage.

  The need to resolve here should only happen after a heuristic solution.
  (Note default OSI implementation of optimalBasisIsAvailable always returns
  false.)
*/
    if (solverCharacteristics_->warmStart()&&
        !solver_->optimalBasisIsAvailable()) {
      //printf("XXXXYY no opt basis\n");
      resolve(node ? node->nodeInfo() : NULL,3);
    }
    if (nextRowCut_) {
      // branch was a cut - add it
      theseCuts.insert(*nextRowCut_);
      if (handler_->logLevel()>1)
        nextRowCut_->print();
      const OsiRowCut * cut=nextRowCut_;
      double lb = cut->lb();
      double ub = cut->ub();
      int n=cut->row().getNumElements();
      const int * column = cut->row().getIndices();
      const double * element = cut->row().getElements();
      double sum=0.0;
      for (int i=0;i<n;i++) {
        int iColumn = column[i];
        double value = element[i];
        //if (cbcColSolution_[iColumn]>1.0e-7)
        //printf("value of %d is %g\n",iColumn,cbcColSolution_[iColumn]);
        sum += value * cbcColSolution_[iColumn];
      }
      delete nextRowCut_;
      nextRowCut_=NULL;
      if (handler_->logLevel()>1)
        printf("applying branch cut, sum is %g, bounds %g %g\n",sum,lb,ub);
      // possibly extend whichGenerator
      resizeWhichGenerator(numberViolated, numberViolated+1);
      // set whichgenerator (also serves as marker to say don't delete0
      whichGenerator_[numberViolated++]=-2;
    }

    // reset probing info
    if (probingInfo_)
      probingInfo_->initializeFixing();
    int i;
    if ((threadMode_&2)==0||numberNodes_) {
      for (i = 0;i<numberCutGenerators_;i++) {
        int numberRowCutsBefore = theseCuts.sizeRowCuts() ;
        int numberColumnCutsBefore = theseCuts.sizeColCuts() ;
        int numberRowCutsAfter = numberRowCutsBefore;
        int numberColumnCutsAfter = numberColumnCutsBefore;
        bool generate = generator_[i]->normal();
        // skip if not optimal and should be (maybe a cut generator has fixed variables)
        if (generator_[i]->needsOptimalBasis()&&!solver_->basisIsAvailable())
          generate=false;
        if (generator_[i]->switchedOff())
          generate=false;;
        if (generate) {
          bool mustResolve = 
            generator_[i]->generateCuts(theseCuts,fullScan,solver_,node) ;
          numberRowCutsAfter = theseCuts.sizeRowCuts() ;
          if(numberRowCutsBefore < numberRowCutsAfter &&
             generator_[i]->mustCallAgain())
            keepGoing=true; // say must go round
          // Check last cut to see if infeasible
          if(numberRowCutsBefore < numberRowCutsAfter) {
            const OsiRowCut * thisCut = theseCuts.rowCutPtr(numberRowCutsAfter-1) ;
            if (thisCut->lb()>thisCut->ub()) {
              feasible = false; // sub-problem is infeasible
              break;
            }
          }
#ifdef CBC_DEBUG
          {
            int k ;
            for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
              OsiRowCut thisCut = theseCuts.rowCut(k) ;
              /* check size of elements.
                 We can allow smaller but this helps debug generators as it
                 is unsafe to have small elements */
              int n=thisCut.row().getNumElements();
              const int * column = thisCut.row().getIndices();
              const double * element = thisCut.row().getElements();
              //assert (n);
              for (int i=0;i<n;i++) {
                double value = element[i];
                assert(fabs(value)>1.0e-12&&fabs(value)<1.0e20);
              }
            }
          }
#endif
          if (mustResolve) {
            int returncode = resolve(node ? node->nodeInfo() : NULL,2);
            feasible = returnCode  != 0 ;
            if (returncode<0)
              numberTries=0;
            if ((specialOptions_&1)!=0) {
              debugger = solver_->getRowCutDebugger() ;
              if (debugger) 
                onOptimalPath = (debugger->onOptimalPath(*solver_)) ;
              else
                onOptimalPath=false;
              if (onOptimalPath && !solver_->isDualObjectiveLimitReached())
                assert(feasible) ;
            }
            if (!feasible)
              break ;
          }
        }
        numberRowCutsAfter = theseCuts.sizeRowCuts() ;
        numberColumnCutsAfter = theseCuts.sizeColCuts() ;
        
        if ((specialOptions_&1)!=0) {
          if (onOptimalPath) {
            int k ;
            for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
              OsiRowCut thisCut = theseCuts.rowCut(k) ;
              if(debugger->invalidCut(thisCut)) {
                solver_->writeMps("badCut");
#ifdef NDEBUG
                printf("Cut generator %d (%s) produced invalid cut (%dth in this go)\n",
                       i,generator_[i]->cutGeneratorName(),k-numberRowCutsBefore);
                abort();
#endif
              }
              assert(!debugger->invalidCut(thisCut)) ;
            }
          }
        }
/*
  The cut generator has done its thing, and maybe it generated some
  cuts.  Do a bit of bookkeeping: load
  whichGenerator[i] with the index of the generator responsible for a cut,
  and place cuts flagged as global in the global cut pool for the model.

  lastNumberCuts is the sum of cuts added in previous iterations; it's the
  offset to the proper starting position in whichGenerator.
*/
        int numberBefore =
          numberRowCutsBefore+numberColumnCutsBefore+lastNumberCuts ;
        int numberAfter =
          numberRowCutsAfter+numberColumnCutsAfter+lastNumberCuts ;
        // possibly extend whichGenerator
        resizeWhichGenerator(numberBefore, numberAfter);
        int j ;
        if (fullScan) {
          // counts
          countColumnCuts[i] += numberColumnCutsAfter-numberColumnCutsBefore ;
        }
        countRowCuts[i] += numberRowCutsAfter-numberRowCutsBefore ;
        
        bool dodgyCuts=false;
        for (j = numberRowCutsBefore;j<numberRowCutsAfter;j++) {
          const OsiRowCut * thisCut = theseCuts.rowCutPtr(j) ;
          if (thisCut->lb()>1.0e10||thisCut->ub()<-1.0e10) {
            dodgyCuts=true;
            break;
          }
          whichGenerator_[numberBefore++] = i ;
          if (thisCut->lb()>thisCut->ub())
            violated=-2; // sub-problem is infeasible
          if (thisCut->globallyValid()) {
            // add to global list
            OsiRowCut newCut(*thisCut);
            newCut.setGloballyValid(true);
            newCut.mutableRow().setTestForDuplicateIndex(false);
            globalCuts_.insert(newCut) ;
          }
        }
        if (dodgyCuts) {
          for (int k=numberRowCutsAfter-1;k>=j;k--) {
            const OsiRowCut * thisCut = theseCuts.rowCutPtr(k) ;
            if (thisCut->lb()>thisCut->ub())
              violated=-2; // sub-problem is infeasible
            if (thisCut->lb()>1.0e10||thisCut->ub()<-1.0e10) 
              theseCuts.eraseRowCut(k);
          }
          numberRowCutsAfter = theseCuts.sizeRowCuts() ;
          for (;j<numberRowCutsAfter;j++) {
            const OsiRowCut * thisCut = theseCuts.rowCutPtr(j) ;
            whichGenerator_[numberBefore++] = i ;
            if (thisCut->globallyValid()) {
              // add to global list
              OsiRowCut newCut(*thisCut);
              newCut.setGloballyValid(true);
              newCut.mutableRow().setTestForDuplicateIndex(false);
              globalCuts_.insert(newCut) ;
            }
          }
        }
        for (j = numberColumnCutsBefore;j<numberColumnCutsAfter;j++) {
          whichGenerator_[numberBefore++] = i ;
          const OsiColCut * thisCut = theseCuts.colCutPtr(j) ;
          if (thisCut->globallyValid()) {
            // add to global list
            OsiColCut newCut(*thisCut);
            newCut.setGloballyValid(true);
            globalCuts_.insert(newCut) ;
          }
        }
      }
      // Add in any violated saved cuts
      if (!theseCuts.sizeRowCuts()&&!theseCuts.sizeColCuts()) {
        int numberOld = theseCuts.sizeRowCuts()+lastNumberCuts;
        int numberCuts = slackCuts.sizeRowCuts() ;
        int i;
        // possibly extend whichGenerator
        resizeWhichGenerator(numberOld, numberOld+numberCuts);
        for ( i = 0;i<numberCuts;i++) {
          const OsiRowCut * thisCut = slackCuts.rowCutPtr(i) ;
          if (thisCut->violated(cbcColSolution_)>100.0*primalTolerance) {
            if (messageHandler()->logLevel()>2)
              printf("Old cut added - violation %g\n",
                     thisCut->violated(cbcColSolution_)) ;
            whichGenerator_[numberOld++]=-1;
            theseCuts.insert(*thisCut) ;
          }
        }
      }
    } else {
      // do cuts independently
      OsiCuts * eachCuts = new OsiCuts [numberCutGenerators_];;
#ifdef CBC_THREAD
      if (!threadModel) {
#endif
        // generate cuts
        for (i = 0;i<numberCutGenerators_;i++) {
          bool generate = generator_[i]->normal();
          // skip if not optimal and should be (maybe a cut generator has fixed variables)
          if (generator_[i]->needsOptimalBasis()&&!solver_->basisIsAvailable())
            generate=false;
          if (generator_[i]->switchedOff())
            generate=false;;
          if (generate) 
            generator_[i]->generateCuts(eachCuts[i],fullScan,solver_,node) ;
        }
#ifdef CBC_THREAD
      } else {
        for (i=0;i<numberThreads_;i++) {
          // set solver here after cloning
          threadModel[i]->solver_=solver_->clone();
          threadModel[i]->numberNodes_ = (fullScan) ? 1 : 0;
        }
        // generate cuts
        for (i = 0;i<numberCutGenerators_;i++) {
          bool generate = generator_[i]->normal();
          // skip if not optimal and should be (maybe a cut generator has fixed variables)
          if (generator_[i]->needsOptimalBasis()&&!solver_->basisIsAvailable())
            generate=false;
          if (generator_[i]->switchedOff())
            generate=false;;
          if (generate) { 
            bool finished=false;
            int iThread=-1;
            // see if any available
            for (iThread=0;iThread<numberThreads_;iThread++) {
              if (threadInfo[iThread].returnCode) {
                finished=true;
                break;
              } else if (threadInfo[iThread].returnCode==0) {
                pthread_cond_signal(threadInfo[iThread].condition2); // unlock
              }
            }
            while (!finished) {
              pthread_mutex_lock(&condition_mutex);
              struct timespec absTime;
              clock_gettime(CLOCK_REALTIME,&absTime);
              absTime.tv_nsec += 1000000; // millisecond
              if (absTime.tv_nsec>=1000000000) {
                absTime.tv_nsec -= 1000000000;
                absTime.tv_sec++;
              }
              pthread_cond_timedwait(&condition_main,&condition_mutex,&absTime);
              pthread_mutex_unlock(&condition_mutex);
              for (iThread=0;iThread<numberThreads_;iThread++) {
                if (threadInfo[iThread].returnCode>0) {
                  finished=true;
                  break;
                } else if (threadInfo[iThread].returnCode==0) {
                  pthread_cond_signal(threadInfo[iThread].condition2); // unlock
                }
              }
            }
            assert (iThread<numberThreads_);
            assert (threadInfo[iThread].returnCode);
            threadModel[iThread]->generator_[0]=generator_[i];
            threadModel[iThread]->object_ = (OsiObject **) (eachCuts+i);
            // allow to start
            threadInfo[iThread].returnCode=0;
            pthread_cond_signal(threadInfo[iThread].condition2); // unlock
          }
        }
        // wait
        for (int iThread=0;iThread<numberThreads_;iThread++) {
          if (threadInfo[iThread].returnCode==0) {
            bool finished=false;
            pthread_cond_signal(threadInfo[iThread].condition2); // unlock
            while (!finished) {
              pthread_mutex_lock(&condition_mutex);
              struct timespec absTime;
              clock_gettime(CLOCK_REALTIME,&absTime);
              absTime.tv_nsec += 1000000; // millisecond
              if (absTime.tv_nsec>=1000000000) {
                absTime.tv_nsec -= 1000000000;
                absTime.tv_sec++;
              }
              pthread_cond_timedwait(&condition_main,&condition_mutex,&absTime);
              pthread_mutex_unlock(&condition_mutex);
              if (threadInfo[iThread].returnCode>0) {
                finished=true;
                break;
              } else if (threadInfo[iThread].returnCode==0) {
                pthread_cond_signal(threadInfo[iThread].condition2); // unlock
              }
            }
          }
          assert (threadInfo[iThread].returnCode);
          // say available
          threadInfo[iThread].returnCode=-1;
          delete threadModel[iThread]->solver_;
          threadModel[iThread]->solver_=NULL;
        }
      }
#endif
      // Now put together
      for (i = 0;i<numberCutGenerators_;i++) {
        // add column cuts
        int numberColumnCutsBefore = theseCuts.sizeColCuts() ;
        int numberColumnCuts = eachCuts[i].sizeColCuts();
        int numberColumnCutsAfter = numberColumnCutsBefore
          + numberColumnCuts;
        int j;
        for (j=0;j<numberColumnCuts;j++) {
          theseCuts.insert(eachCuts[i].colCut(j));
        }
        int numberRowCutsBefore = theseCuts.sizeRowCuts() ;
        int numberRowCuts = eachCuts[i].sizeRowCuts();
        int numberRowCutsAfter = numberRowCutsBefore
          + numberRowCuts;
        if (numberRowCuts) {
          for (j=0;j<numberRowCuts;j++) {
            const OsiRowCut * thisCut = eachCuts[i].rowCutPtr(j) ;
            if (thisCut->lb()<=1.0e10&&thisCut->ub()>=-1.0e10) 
              theseCuts.insert(eachCuts[i].rowCut(j));
          }
          if (generator_[i]->mustCallAgain())
            keepGoing=true; // say must go round
          // Check last cut to see if infeasible
          const OsiRowCut * thisCut = theseCuts.rowCutPtr(numberRowCutsAfter-1) ;
          if (thisCut->lb()>thisCut->ub()) {
            feasible = false; // sub-problem is infeasible
            break;
          }
        }
#ifdef CBC_DEBUG
        {
          int k ;
          for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
            OsiRowCut thisCut = theseCuts.rowCut(k) ;
            /* check size of elements.
               We can allow smaller but this helps debug generators as it
               is unsafe to have small elements */
            int n=thisCut.row().getNumElements();
            const int * column = thisCut.row().getIndices();
            const double * element = thisCut.row().getElements();
            //assert (n);
            for (int i=0;i<n;i++) {
              double value = element[i];
              assert(fabs(value)>1.0e-12&&fabs(value)<1.0e20);
            }
          }
        }
#endif
        if ((specialOptions_&1)!=0) {
          if (onOptimalPath) {
            int k ;
            for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
              OsiRowCut thisCut = theseCuts.rowCut(k) ;
              if(debugger->invalidCut(thisCut)) {
                solver_->writeMps("badCut");
#ifdef NDEBUG
                printf("Cut generator %d (%s) produced invalid cut (%dth in this go)\n",
                       i,generator_[i]->cutGeneratorName(),k-numberRowCutsBefore);
                abort();
#endif
              }
              assert(!debugger->invalidCut(thisCut)) ;
            }
          }
        }
/*
  The cut generator has done its thing, and maybe it generated some
  cuts.  Do a bit of bookkeeping: load
  whichGenerator[i] with the index of the generator responsible for a cut,
  and place cuts flagged as global in the global cut pool for the model.

  lastNumberCuts is the sum of cuts added in previous iterations; it's the
  offset to the proper starting position in whichGenerator.
*/
        int numberBefore =
          numberRowCutsBefore+numberColumnCutsBefore+lastNumberCuts ;
        int numberAfter =
          numberRowCutsAfter+numberColumnCutsAfter+lastNumberCuts ;
        // possibly extend whichGenerator
        resizeWhichGenerator(numberBefore, numberAfter);
        if (fullScan) {
          // counts
          countColumnCuts[i] += numberColumnCutsAfter-numberColumnCutsBefore ;
        }
        countRowCuts[i] += numberRowCutsAfter-numberRowCutsBefore ;
        
        for (j = numberRowCutsBefore;j<numberRowCutsAfter;j++) {
          whichGenerator_[numberBefore++] = i ;
          const OsiRowCut * thisCut = theseCuts.rowCutPtr(j) ;
          if (thisCut->lb()>thisCut->ub())
            violated=-2; // sub-problem is infeasible
          if (thisCut->globallyValid()) {
            // add to global list
            OsiRowCut newCut(*thisCut);
            newCut.setGloballyValid(true);
            newCut.mutableRow().setTestForDuplicateIndex(false);
            globalCuts_.insert(newCut) ;
          }
        }
        for (j = numberColumnCutsBefore;j<numberColumnCutsAfter;j++) {
          whichGenerator_[numberBefore++] = i ;
          const OsiColCut * thisCut = theseCuts.colCutPtr(j) ;
          if (thisCut->globallyValid()) {
            // add to global list
            OsiColCut newCut(*thisCut);
            newCut.setGloballyValid(true);
            globalCuts_.insert(newCut) ;
          }
        }
      }
      // Add in any violated saved cuts
      if (!theseCuts.sizeRowCuts()&&!theseCuts.sizeColCuts()) {
        int numberOld = theseCuts.sizeRowCuts()+lastNumberCuts;
        int numberCuts = slackCuts.sizeRowCuts() ;
        int i;
        // possibly extend whichGenerator
        resizeWhichGenerator(numberOld, numberOld+numberCuts);
        for ( i = 0;i<numberCuts;i++) {
          const OsiRowCut * thisCut = slackCuts.rowCutPtr(i) ;
          if (thisCut->violated(cbcColSolution_)>100.0*primalTolerance) {
            if (messageHandler()->logLevel()>2)
              printf("Old cut added - violation %g\n",
                     thisCut->violated(cbcColSolution_)) ;
            whichGenerator_[numberOld++]=-1;
            theseCuts.insert(*thisCut) ;
          }
        }
      }
      delete [] eachCuts;
    }
    //if (!feasible)
    //break;
/*
  End of the loop to exercise each generator - try heuristics
  - unless at root node and first pass
*/
    if (numberNodes_||currentPassNumber_!=1) {
      double * newSolution = new double [numberColumns] ;
      double heuristicValue = getCutoff() ;
      int found = -1; // no solution found
      for (i = 0;i<numberHeuristics_;i++) {
        // see if heuristic will do anything
        double saveValue = heuristicValue ;
        int ifSol = 
          heuristic_[i]->solution(heuristicValue,
                                  newSolution,
                                  theseCuts) ;
        if (ifSol>0) {
          // better solution found
          found = i ;
          incrementUsed(newSolution);
        } else if (ifSol<0) {
          heuristicValue = saveValue ;
        }
      }
/*
  Did any of the heuristics turn up a new solution? Record it before we free
  the vector.
*/
      if (found >= 0) { 
        phase_=4;
        incrementUsed(newSolution);
        lastHeuristic_ = heuristic_[found];
        setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
        CbcTreeLocal * tree 
          = dynamic_cast<CbcTreeLocal *> (tree_);
        if (tree)
          tree->passInSolution(bestSolution_,heuristicValue);
      }
      delete [] newSolution ;
    }

#if 0
    // switch on to get all cuts printed
    theseCuts.printCuts() ;
#endif
    int numberColumnCuts = theseCuts.sizeColCuts() ;
    int numberRowCuts = theseCuts.sizeRowCuts() ;
    if (violated>=0)
      violated = numberRowCuts + numberColumnCuts ;
/*
  Apply column cuts (aka bound tightening). This may be partially redundant
  for column cuts returned by CglProbing, as generateCuts installs bounds
  from CglProbing when it determines it can fix a variable.

  TODO: Looks like the use of violated has evolved. The value set above is
        completely ignored. All that's left is violated == -1 indicates some
        cut is violated, violated == -2 indicates infeasibility. Only
        infeasibility warrants exceptional action.

  TODO: Strikes me that this code will fail to detect infeasibility, because
        the breaks escape the inner loops but the outer loop keeps going.
        Infeasibility in an early cut will be overwritten if a later cut is
        merely violated.
*/
    if (numberColumnCuts) {

#ifdef CBC_DEBUG
      double * oldLower = new double [numberColumns] ;
      double * oldUpper = new double [numberColumns] ;
      memcpy(oldLower,cbcColLower_,numberColumns*sizeof(double)) ;
      memcpy(oldUpper,cbcColUpper_,numberColumns*sizeof(double)) ;
#endif

      double integerTolerance = getDblParam(CbcIntegerTolerance) ;
      for (int i = 0;i<numberColumnCuts;i++) {
        const OsiColCut * thisCut = theseCuts.colCutPtr(i) ;
        const CoinPackedVector & lbs = thisCut->lbs() ;
        const CoinPackedVector & ubs = thisCut->ubs() ;
        int j ;
        int n ;
        const int * which ;
        const double * values ;
        n = lbs.getNumElements() ;
        which = lbs.getIndices() ;
        values = lbs.getElements() ;
        for (j = 0;j<n;j++) {
          int iColumn = which[j] ;
          double value = cbcColSolution_[iColumn] ;
#if CBC_DEBUG>1
          printf("%d %g %g %g %g\n",iColumn,oldLower[iColumn],
                 cbcColSolution_[iColumn],oldUpper[iColumn],values[j]) ;
#endif
          solver_->setColLower(iColumn,values[j]) ;
          if (value<values[j]-integerTolerance)
            violated = -1 ;
          if (values[j]>cbcColUpper_[iColumn]+integerTolerance) {
            // infeasible
            violated = -2 ;
            break ;
          }
        }
        n = ubs.getNumElements() ;
        which = ubs.getIndices() ;
        values = ubs.getElements() ;
        for (j = 0;j<n;j++) {
          int iColumn = which[j] ;
          double value = cbcColSolution_[iColumn] ;
#if CBC_DEBUG>1
          printf("%d %g %g %g %g\n",iColumn,oldLower[iColumn],
                 cbcColSolution_[iColumn],oldUpper[iColumn],values[j]) ;
#endif
          solver_->setColUpper(iColumn,values[j]) ;
          if (value>values[j]+integerTolerance)
            violated = -1 ;
          if (values[j]<cbcColLower_[iColumn]-integerTolerance) {
            // infeasible
            violated = -2 ;
            break ;
          }
        }
      }
#ifdef CBC_DEBUG
      delete [] oldLower ;
      delete [] oldUpper ;
#endif
    }
/*
  End installation of column cuts. The break here escapes the numberTries
  loop.
*/
    if (violated == -2||!feasible) {
      // infeasible
      feasible = false ;
      violated = -2;
      if (!numberNodes_) 
        messageHandler()->message(CBC_INFEAS,
                                  messages())
                                    << CoinMessageEol ;
      break ;
    }
/*
  Now apply the row (constraint) cuts. This is a bit more work because we need
  to obtain and augment the current basis.

  TODO: Why do this work, if there are no row cuts? The current basis will do
        just fine.
*/
    int numberRowsNow = solver_->getNumRows() ;
#ifndef NDEBUG
    assert(numberRowsNow == numberRowsAtStart+lastNumberCuts) ;
#else
    // ? maybe clue to threaded problems
    if(numberRowsNow != numberRowsAtStart+lastNumberCuts) {
      fprintf(stderr,"*** threaded error - numberRowsNow(%d) != numberRowsAtStart(%d)+lastNumberCuts(%d)\n",
              numberRowsNow,numberRowsAtStart,lastNumberCuts);
      fprintf(stdout,"*** threaded error - numberRowsNow(%d) != numberRowsAtStart(%d)+lastNumberCuts(%d)\n",
              numberRowsNow,numberRowsAtStart,lastNumberCuts);
      abort();
    }
#endif
    int numberToAdd = theseCuts.sizeRowCuts() ;
    numberNewCuts_ = lastNumberCuts+numberToAdd ;
/*
  Now actually add the row cuts and reoptimise.

  Install the cuts in the solver using applyRowCuts and
  augment the basis with the corresponding slack. We also add each row cut to
  the set of row cuts (cuts.insert()) supplied as a parameter. The new basis
  must be set with setWarmStart().

  TODO: Seems to me the original code could allocate addCuts with size 0, if
        numberRowCuts was 0 and numberColumnCuts was nonzero. That might
        explain the memory fault noted in the comment by AJK.  Unfortunately,
        just commenting out the delete[] results in massive memory leaks. Try
        a revision to separate the row cut case. Why do we need addCuts at
        all? A typing issue, apparently: OsiCut vs. OsiRowCut.

  TODO: It looks to me as if numberToAdd and numberRowCuts are identical at
        this point. Confirm & get rid of one of them.

  TODO: Any reason why the three loops can't be consolidated?
*/
    if (numberRowCuts > 0 || numberColumnCuts > 0)
    { if (numberToAdd > 0)
      { int i ;
        // Faster to add all at once
        const OsiRowCut ** addCuts = new const OsiRowCut * [numberToAdd] ;
        for (i = 0 ; i < numberToAdd ; i++)
        { addCuts[i] = &theseCuts.rowCut(i) ; }
        solver_->applyRowCuts(numberToAdd,addCuts) ;
        // AJK this caused a memory fault on Win32
        // may be okay now with ** form
        delete [] addCuts ;
        for (i = 0 ; i < numberToAdd ; i++)
        { cuts.insert(theseCuts.rowCut(i)) ; }
        CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(solver_->getWarmStart()) ;
        assert(basis != NULL); // make sure not volume
/* dylp bug

  Consistent size used by OsiDylp as sanity check. Implicit resize seen
  as an error. Hence this call to resize is necessary.
*/
        basis->resize(numberRowsAtStart+numberNewCuts_,numberColumns) ;
        for (i = 0 ; i < numberToAdd ; i++) 
        { basis->setArtifStatus(numberRowsNow+i,
                                 CoinWarmStartBasis::basic) ; }
        if (solver_->setWarmStart(basis) == false)
        { throw CoinError("Fail setWarmStart() after cut installation.",
                          "solveWithCuts","CbcModel") ; }
        delete basis;
      }
      feasible = ( resolve(node ? node->nodeInfo() : NULL,2) != 0) ;
      if ( getCurrentSeconds() > dblParam_[CbcMaximumSeconds] )
        numberTries=0; // exit
#     ifdef CBC_DEBUG
      printf("Obj value after cuts %g %d rows\n",solver_->getObjValue(),
              solver_->getNumRows()) ;
      if (onOptimalPath && !solver_->isDualObjectiveLimitReached())
        assert(feasible) ;
#     endif
    }
/*
  No cuts. Cut short the cut generation (numberTries) loop.
*/
    else
    { numberTries = 0 ; }
/*
  If the problem is still feasible, first, call takeOffCuts() to remove cuts
  that are now slack. takeOffCuts() will call the solver to reoptimise if
  that's needed to restore a valid solution.

  Next, see if we should quit due to diminishing returns:
    * we've tried three rounds of cut generation and we're getting
      insufficient improvement in the objective; or
    * we generated no cuts; or
    * the solver declared optimality with 0 iterations after we added the
      cuts generated in this round.
  If we decide to keep going, prep for the next iteration.

  It just seems more safe to tell takeOffCuts() to call resolve(), even if
  we're not continuing cut generation. Otherwise code executed between here
  and final disposition of the node will need to be careful not to access the
  lp solution. It can happen that we lose feasibility in takeOffCuts ---
  numerical jitters when the cutoff bound is epsilon less than the current
  best, and we're evaluating an alternative optimum.

  TODO: After successive rounds of code motion, there seems no need to
        distinguish between the two checks for aborting the cut generation
        loop. Confirm and clean up.
*/
    if (feasible)
    { int cutIterations = solver_->getIterationCount() ;
      if (numberOldActiveCuts_+numberNewCuts_) {
        OsiCuts * saveCuts = node ? NULL : &slackCuts;
        takeOffCuts(cuts,resolveAfterTakeOffCuts_,saveCuts) ;
        if (solver_->isDualObjectiveLimitReached()&&resolveAfterTakeOffCuts_)
          { feasible = false ;
#       ifdef CBC_DEBUG
          double z = solver_->getObjValue() ;
          double cut = getCutoff() ;
          printf("Lost feasibility by %g in takeOffCuts; z = %g, cutoff = %g\n",
                 z-cut,z,cut) ;
#       endif
          }
      }
      if (feasible) {
        numberRowsAtStart = numberOldActiveCuts_+numberRowsAtContinuous_ ;
        lastNumberCuts = numberNewCuts_ ;
        if (direction*solver_->getObjValue() < lastObjective+minimumDrop &&
            currentPassNumber_ >= 3 && !keepGoing)
          { numberTries = 0 ; }
        if (numberRowCuts+numberColumnCuts == 0 || cutIterations == 0)
          { break ; }
        if (numberTries > 0) {
          reducedCostFix() ;
          lastObjective = direction*solver_->getObjValue() ;
        }
      }
    }
/*
  We've lost feasibility --- this node won't be referencing the cuts we've
  been collecting, so decrement the reference counts.
*/
    if (!feasible)
    { int i ;
      if (currentNumberCuts_) {
        lockThread();
        for (i = 0;i<currentNumberCuts_;i++) {
          // take off node
          if (addedCuts_[i]) {
            if (!addedCuts_[i]->decrement())
              delete addedCuts_[i] ;
            addedCuts_[i] = NULL ;
          }
        }
      }
      numberTries = 0 ;
    }
  } while (numberTries>0||keepGoing) ;
  {
    // switch on
    for (int i = 0;i<numberCutGenerators_;i++) 
      generator_[i]->setSwitchedOff(false);
  }
  //check feasibility.
  //If solution seems to be integer feasible calling setBestSolution
  //will eventually add extra global cuts which we need to install at
  //the nodes


  if(feasible&&solverCharacteristics_->solutionAddsCuts())  //check integer feasibility
  {
    bool integerFeasible = true;
    const double * save = testSolution_;
    testSolution_ = solver_->getColSolution();
    // point to useful information
    OsiBranchingInformation usefulInfo=usefulInformation();
    for (int i=0;i<numberObjects_ && integerFeasible;i++)
    {
      int preferredWay;
      double infeasibility = object_[i]->infeasibility(&usefulInfo,preferredWay);
      if(infeasibility)
        integerFeasible = false;
    }
    testSolution_ = save;
    if(integerFeasible)//update
    {
      double objValue = solver_->getObjValue();
      int numberGlobalBefore = globalCuts_.sizeRowCuts();
      // SOLUTION2 so won't up cutoff or print message
      setBestSolution(CBC_SOLUTION2, objValue, 
                      solver_->getColSolution(),0);
      int numberGlobalAfter = globalCuts_.sizeRowCuts();
      int numberToAdd = numberGlobalAfter - numberGlobalBefore;
      if(numberToAdd > 0)
        //We have added some cuts say they are tight at that node
        //Basis and lp should already have been updated
      {
        feasible = (solver_->isProvenOptimal() &&
                    !solver_->isDualObjectiveLimitReached()) ;
        if(feasible)
        {
          int numberCuts = numberNewCuts_ = cuts.sizeRowCuts();
      // possibly extend whichGenerator
          resizeWhichGenerator(numberCuts, numberToAdd+numberCuts);
          
          for (int i = numberGlobalBefore ; i < numberGlobalAfter ; i++)
            {        
              whichGenerator_[numberNewCuts_++]=-1;
#ifndef GLOBAL_CUTS_JUST_POINTERS
              cuts.insert(globalCuts_.rowCut(i)) ; 
#else
              OsiRowCut * rowCutPointer = globalCuts_.rowCutPtr(i);
              cuts.insert(rowCutPointer) ; 
#endif
            }
          numberNewCuts_ = lastNumberCuts+numberToAdd;
          //now take off the cuts which are not tight anymore
          takeOffCuts(cuts,resolveAfterTakeOffCuts_, NULL) ;
          if (solver_->isDualObjectiveLimitReached()&&resolveAfterTakeOffCuts_)
            { feasible = false ;}
        }
        if(!feasible) //node will be fathomed
          { 
          for (int i = 0;i<currentNumberCuts_;i++) 
            {
            // take off node
            if (addedCuts_[i])
              {
                if (!addedCuts_[i]->decrement())
                  delete addedCuts_[i] ;
                addedCuts_[i] = NULL ;
              }
            }
        }
      }
    }
  }
/*
  Reduced cost fix at end. Must also check feasible, in case we've popped out
  because a generator indicated we're infeasible.
*/
  if (feasible && solver_->isProvenOptimal())
    reducedCostFix();
  // If at root node do heuristics
  if (!numberNodes_) {
    // First see if any cuts are slack
    int numberRows = solver_->getNumRows();
    int numberAdded = numberRows-numberRowsAtContinuous_;
    if (numberAdded) {
      CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(solver_->getWarmStart()) ;
      assert(basis != NULL);
      int * added = new int[numberAdded];
      int nDelete = 0;
      for (int j=numberRowsAtContinuous_;j<numberRows;j++) {
        if (basis->getArtifStatus(j)==CoinWarmStartBasis::basic) {
          //printf("%d slack!\n",j);
          added[nDelete++]=j;
        }
      }
      if (nDelete) {
        solver_->deleteRows(nDelete,added);
      }
      delete [] added;
      delete basis ;
    }
    // mark so heuristics can tell
    int savePass=currentPassNumber_;
    currentPassNumber_=999999;
    double * newSolution = new double [numberColumns] ;
    double heuristicValue = getCutoff() ;
    int found = -1; // no solution found
    for (int i = 0;i<numberHeuristics_;i++) {
      // see if heuristic will do anything
      double saveValue = heuristicValue ;
      int ifSol = heuristic_[i]->solution(heuristicValue,
                                          newSolution);
      if (ifSol>0) {
        // better solution found
        found = i ;
        incrementUsed(newSolution);
      } else {
        heuristicValue = saveValue ;
      }
    }
    currentPassNumber_=savePass;
    if (found >= 0) { 
      phase_=4;
      incrementUsed(newSolution);
      lastHeuristic_ = heuristic_[found];
      setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
    }
    delete [] newSolution ;
  }
  // Up change due to cuts
  if (feasible)
    sumChangeObjective2_ += solver_->getObjValue()*solver_->getObjSense()
      - objectiveValue ;
  //if ((numberNodes_%100)==0)
  //printf("XXb sum obj changed by %g\n",sumChangeObjective2_);
/*
  End of cut generation loop.

  Now, consider if we want to disable or adjust the frequency of use for any
  of the cut generators. If the client specified a positive number for
  howOften, it will never change. If the original value was negative, it'll
  be converted to 1000000+|howOften|, and this value will be adjusted each
  time fullScan is true. Actual cut generation is performed every
  howOften%1000000 nodes; the 1000000 offset is just a convenient way to
  specify that the frequency is adjustable.

  During cut generation, we recorded the number of cuts produced by each
  generator for this node. For all cuts, whichGenerator records the generator
  that produced a cut.

  TODO: All this should probably be hidden in a method of the CbcCutGenerator
  class.

  TODO: Can the loop that scans over whichGenerator to accumulate per generator
        counts be replaced by values in countRowCuts and countColumnCuts?
*/
#ifdef NODE_LOG
  int fatherNum = (node == NULL) ? -1 : node->nodeNumber();
  double value =  (node == NULL) ? -1 : node->branchingObject()->value();
  string bigOne = (solver_->getIterationCount() > 30) ? "*******" : "";
  string way = (node == NULL) ? "" : (node->branchingObject()->way())==1 ? "Down" : "Up";
  std::cout<<"Node "<<numberNodes_<<", father "<<fatherNum<<", #iterations "<<solver_->getIterationCount()<<", sol value : "<<solver_->getObjValue()<<std::endl;
#endif
  if (fullScan&&numberCutGenerators_) {
    /* If cuts just at root node then it will probably be faster to
       update matrix and leave all in */
    int willBeCutsInTree=0;
    double thisObjective = solver_->getObjValue()*direction ;
    // get sizes
    int numberRowsAdded = solver_->getNumRows()-numberRowsAtStart;
    CoinBigIndex numberElementsAdded =  solver_->getNumElements()-numberElementsAtStart ;
    double densityOld = ((double) numberElementsAtStart)/((double) numberRowsAtStart);
    double densityNew = numberRowsAdded ? ((double) (numberElementsAdded))/((double) numberRowsAdded)
      : 0.0;
    if (!numberNodes_) {
      if (numberRowsAdded)
        handler_->message(CBC_CUTS_STATS,messages_)
          <<numberRowsAdded
          <<densityNew
          <<CoinMessageEol ;
      if (thisObjective-startObjective<1.0e-5&&numberElementsAdded>0.2*numberElementsAtStart)
        willBeCutsInTree=-1;
    }
    if ((numberRowsAdded>100+0.5*numberRowsAtStart
         ||numberElementsAdded>0.5*numberElementsAtStart)
        &&(densityNew>200.0&&numberRowsAdded>100&&densityNew>2.0*densityOld)) {
      // much bigger
      //if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5)
      //willBeCutsInTree=-1;
      //printf("Cuts will be taken off , %d rows added with density %g\n",
      //     numberRowsAdded,densityNew);
    }
    if (densityNew>100.0&&numberRowsAdded>2&&densityNew>2.0*densityOld) {
      //if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5)
      //willBeCutsInTree=-2;
      //printf("Density says no cuts ? , %d rows added with density %g\n",
      //     numberRowsAdded,densityNew);
    }
    // Root node or every so often - see what to turn off
    int i ;
    for (i = 0;i<numberCutGenerators_;i++) {
      int howOften = generator_[i]->howOften() ;
      if (howOften>-90) 
        willBeCutsInTree=0;
    }
    if (!numberNodes_)
      handler_->message(CBC_ROOT,messages_)
        <<numberNewCuts_
        <<startObjective<<thisObjective
        <<currentPassNumber_
        <<CoinMessageEol ;
    int * count = new int[numberCutGenerators_] ;
    memset(count,0,numberCutGenerators_*sizeof(int)) ;
    int numberActiveGenerators=0;
    for (i = 0;i<numberNewCuts_;i++) {
      int iGenerator = whichGenerator_[i];
      if (iGenerator>=0&&iGenerator<numberCutGenerators_)
        count[iGenerator]++ ;
    }
    double totalCuts = 0.0 ;
    //#define JUST_ACTIVE
    for (i = 0;i<numberCutGenerators_;i++) {
      if (countRowCuts[i]||countColumnCuts[i])
        numberActiveGenerators++;
#ifdef JUST_ACTIVE
      totalCuts += count[i] + 5.0*countColumnCuts[i] ;
#else
      totalCuts += countRowCuts[i] + 5.0*countColumnCuts[i] ;
#endif
    }
    int iProbing=-1;
    double small = (0.5* totalCuts) /
      ((double) numberActiveGenerators) ;
    for (i = 0;i<numberCutGenerators_;i++) {
      int howOften = generator_[i]->howOften() ;
      /*  Probing can be set to just do column cuts in treee.
          But if doing good then leave as on */
      bool probingWasOnBut=false;
      CglProbing * probing = dynamic_cast<CglProbing*>(generator_[i]->generator());
      if (probing&&!numberNodes_) {
        iProbing = i;
        if (probing->rowCuts()==-3) {
          probingWasOnBut=true;
          howOften = -98;
          probing->setRowCuts(3);
        }
      }
      if (willBeCutsInTree<0&&howOften==-98)
        howOften =-99;
      if (howOften==-98&&generator_[i]->switchOffIfLessThan()<0) {
        if (thisObjective-startObjective<0.005*fabs(startObjective)+1.0e-5)
          howOften=-99; // switch off
        if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5
            &&5*solver_->getNumRows()<solver_->getNumCols())
          howOften=-99; // switch off
      }
      if (howOften<-99)
        continue ;
      if (howOften<0||howOften >= 1000000) {
        if( !numberNodes_) {
          // If small number switch mostly off
#ifdef JUST_ACTIVE
          double thisCuts = count[i] + 5.0*countColumnCuts[i] ;
#else
          double thisCuts = countRowCuts[i] + 5.0*countColumnCuts[i] ;
#endif
          if (!thisCuts||howOften == -99) {
            if (howOften == -99||howOften == -98) 
              howOften = -100 ;
            else
              howOften = 1000000+SCANCUTS; // wait until next time
          } else if (thisCuts<small) {
            if (howOften!=1&&!probingWasOnBut) {
              if (generator_[i]->whatDepth()<0||howOften!=-1) {
                int k = (int) sqrt(small/thisCuts) ;
                if (howOften!=-98)
                  howOften = k+1000000 ;
                else
                  howOften=-100;
              } else {
                howOften=1;
              }
            } else {
              howOften=1;
              // allow cuts
              probingWasOnBut=false;
            }
          } else {
            if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5&&generator_[i]->whatDepth()<0)
              generator_[i]->setWhatDepth(5);
            howOften = 1+1000000 ;
          }
        }
        // If cuts useless switch off
        if (numberNodes_>=100000&&sumChangeObjective1_>2.0e2*(sumChangeObjective2_+1.0e-12)) {
          howOften = 1000000+SCANCUTS; // wait until next time
          //printf("switch off cut %d due to lack of use\n",i);
        }
      }
      if (!numberNodes_) {
        if (probingWasOnBut&&howOften==-100) {
          probing->setRowCuts(-3);
          howOften=1;
        }
        if (howOften==1)
          generator_[i]->setWhatDepth(1);
        
        if (howOften>=0&&generator_[i]->generator()->mayGenerateRowCutsInTree())
          willBeCutsInTree=1;
      }
      generator_[i]->setHowOften(howOften) ;
      if (howOften>=1000000&&howOften<2000000&&0) {
        // Go to depth
        int bias=1;
        if (howOften==1+1000000)
          generator_[i]->setWhatDepth(bias+1);
        else if (howOften<=10+1000000)
          generator_[i]->setWhatDepth(bias+2);
        else
          generator_[i]->setWhatDepth(bias+1000);
      }
      int newFrequency = generator_[i]->howOften()%1000000 ;
      // increment cut counts
      generator_[i]->incrementNumberCutsInTotal(coun