Changeset 2464 for trunk/Cbc/src/CbcModel.hpp

Timestamp:

Jan 3, 2019 2:03:23 PM (2 years ago)

Author:

unxusr

Message:

.clang-format with proposal for formatting code

File:

• trunk/Cbc/src/CbcModel.hpp (modified) (73 diffs)

trunk/Cbc/src/CbcModel.hpp

@@ -18 +18 @@
 #include "CbcEventHandler.hpp"
 #include "ClpDualRowPivot.hpp"
-
 
 class CbcCutGenerator;
@@ -38 +37 @@
 class CbcStatistics;
 class CbcFullNodeInfo;
-class CbcEventHandler ;
+class CbcEventHandler;
 class CglPreProcess;
 class OsiClpSolverInterface;
@@ -99 +98 @@
 */
 
-class CbcModel  {
+class CbcModel {
 
 public:
-
-    enum CbcIntParam {
-        /** The maximum number of nodes before terminating */
-        CbcMaxNumNode = 0,
-        /** The maximum number of solutions before terminating */
-        CbcMaxNumSol,
-        /** Fathoming discipline
+  enum CbcIntParam {
+    /** The maximum number of nodes before terminating */
+    CbcMaxNumNode = 0,
+    /** The maximum number of solutions before terminating */
+    CbcMaxNumSol,
+    /** Fathoming discipline
 
           Controls objective function comparisons for purposes of fathoming by bound
@@ -117 +115 @@
           the target.
         */
-        CbcFathomDiscipline,
-        /** Adjusts printout
+    CbcFathomDiscipline,
+    /** Adjusts printout
             1 does different node message with number unsatisfied on last branch
         */
-        CbcPrinting,
-        /** Number of branches (may be more than number of nodes as may
+    CbcPrinting,
+    /** Number of branches (may be more than number of nodes as may
             include strong branching) */
-        CbcNumberBranches,
-        /** Just a marker, so that a static sized array can store parameters. */
-        CbcLastIntParam
-    };
-
-    enum CbcDblParam {
-        /** The maximum amount the value of an integer variable can vary from
+    CbcNumberBranches,
+    /** Just a marker, so that a static sized array can store parameters. */
+    CbcLastIntParam
+  };
+
+  enum CbcDblParam {
+    /** The maximum amount the value of an integer variable can vary from
             integer and still be considered feasible. */
-        CbcIntegerTolerance = 0,
-        /** The objective is assumed to worsen by this amount for each
+    CbcIntegerTolerance = 0,
+    /** The objective is assumed to worsen by this amount for each
             integer infeasibility. */
-        CbcInfeasibilityWeight,
-        /** The amount by which to tighten the objective function cutoff when
+    CbcInfeasibilityWeight,
+    /** The amount by which to tighten the objective function cutoff when
             a new solution is discovered. */
-        CbcCutoffIncrement,
-        /** Stop when the gap between the objective value of the best known solution
+    CbcCutoffIncrement,
+    /** Stop when the gap between the objective value of the best known solution
           and the best bound on the objective of any solution is less than this.
 
@@ -145 +143 @@
           client.
         */
-        CbcAllowableGap,
-        /** Stop when the gap between the objective value of the best known solution
+    CbcAllowableGap,
+    /** Stop when the gap between the objective value of the best known solution
           and the best bound on the objective of any solution is less than this
           fraction of of the absolute value of best known solution.
@@ -152 +150 @@
           Code stops if either this test or CbcAllowableGap test succeeds
         */
-        CbcAllowableFractionGap,
-        /** \brief The maximum number of seconds before terminating.
+    CbcAllowableFractionGap,
+    /** \brief The maximum number of seconds before terminating.
                A double should be adequate! */
-        CbcMaximumSeconds,
-        /// Cutoff - stored for speed
-        CbcCurrentCutoff,
-        /// Optimization direction - stored for speed
-        CbcOptimizationDirection,
-        /// Current objective value
-        CbcCurrentObjectiveValue,
-        /// Current minimization objective value
-        CbcCurrentMinimizationObjectiveValue,
-        /** \brief The time at start of model.
+    CbcMaximumSeconds,
+    /// Cutoff - stored for speed
+    CbcCurrentCutoff,
+    /// Optimization direction - stored for speed
+    CbcOptimizationDirection,
+    /// Current objective value
+    CbcCurrentObjectiveValue,
+    /// Current minimization objective value
+    CbcCurrentMinimizationObjectiveValue,
+    /** \brief The time at start of model.
                So that other pieces of code can access */
-        CbcStartSeconds,
-        /** Stop doing heuristics when the gap between the objective value of the
+    CbcStartSeconds,
+    /** Stop doing heuristics when the gap between the objective value of the
             best known solution and the best bound on the objective of any solution
             is less than this.
@@ -174 +172 @@
           client.
         */
-        CbcHeuristicGap,
-        /** Stop doing heuristics when the gap between the objective value of the
+    CbcHeuristicGap,
+    /** Stop doing heuristics when the gap between the objective value of the
             best known solution and the best bound on the objective of any solution
             is less than this fraction of of the absolute value of best known
@@ -182 +180 @@
           Code stops if either this test or CbcAllowableGap test succeeds
         */
-        CbcHeuristicFractionGap,
-        /// Smallest non-zero change on a branch
-        CbcSmallestChange,
-        /// Sum of non-zero changes on a branch
-        CbcSumChange,
-        /// Largest non-zero change on a branch
-        CbcLargestChange,
-        /// Small non-zero change on a branch to be used as guess
-        CbcSmallChange,
-        /** Just a marker, so that a static sized array can store parameters. */
-        CbcLastDblParam
-    };
-
-    //---------------------------------------------------------------------------
+    CbcHeuristicFractionGap,
+    /// Smallest non-zero change on a branch
+    CbcSmallestChange,
+    /// Sum of non-zero changes on a branch
+    CbcSumChange,
+    /// Largest non-zero change on a branch
+    CbcLargestChange,
+    /// Small non-zero change on a branch to be used as guess
+    CbcSmallChange,
+    /** Just a marker, so that a static sized array can store parameters. */
+    CbcLastDblParam
+  };
+
+  //---------------------------------------------------------------------------
 
 public:
-    ///@name Solve methods
-    //@{
-    /** \brief Solve the initial LP relaxation
+  ///@name Solve methods
+  //@{
+  /** \brief Solve the initial LP relaxation
 
       Invoke the solver's %initialSolve() method.
     */
-    void initialSolve();
-
-    /** \brief Invoke the branch \& cut algorithm
+  void initialSolve();
+
+  /** \brief Invoke the branch \& cut algorithm
 
       The method assumes that initialSolve() has been called to solve the
@@ -216 +214 @@
       if 3 then also one line per node
     */
-    void branchAndBound(int doStatistics = 0);
+  void branchAndBound(int doStatistics = 0);
+
 private:
-
-    /** \brief Evaluate a subproblem using cutting planes and heuristics
+  /** \brief Evaluate a subproblem using cutting planes and heuristics
 
       The method invokes a main loop which generates cuts, applies heuristics,
@@ -226 +224 @@
       evaluation.
     */
-    bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
-    /** Generate one round of cuts - serial mode
+  bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node);
+  /** Generate one round of cuts - serial mode
       returns -
       0 - normal
@@ -234 +232 @@
       -1 - infeasible
     */
-    int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
-    /** Generate one round of cuts - parallel mode
+  int serialCuts(OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
+  /** Generate one round of cuts - parallel mode
         returns -
         0 - normal
@@ -242 +240 @@
         -1 - infeasible
     */
-    int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
-    /** Input one node output N nodes to put on tree and optional solution update
+  int parallelCuts(CbcBaseModel *master, OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
+  /** Input one node output N nodes to put on tree and optional solution update
         This should be able to operate in parallel so is given a solver and is const(ish)
         However we will need to keep an array of solver_ and bases and more
@@ -249 +247 @@
         Calling code should always push nodes back on tree
     */
-    CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
-                            int & numberNodesOutput, int & status) ;
-    /// Update size of whichGenerator
-    void resizeWhichGenerator(int numberNow, int numberAfter);
+  CbcNode **solveOneNode(int whichSolver, CbcNode *node,
+    int &numberNodesOutput, int &status);
+  /// Update size of whichGenerator
+  void resizeWhichGenerator(int numberNow, int numberAfter);
+
 public:
 #ifdef CBC_KEEP_DEPRECATED
-    // See if anyone is using these any more!!
-    /** \brief create a clean model from partially fixed problem
+  // See if anyone is using these any more!!
+  /** \brief create a clean model from partially fixed problem
 
       The method creates a new model with given bounds and with no tree.
     */
-    CbcModel *  cleanModel(const double * lower, const double * upper);
-    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
+  CbcModel *cleanModel(const double *lower, const double *upper);
+  /** \brief Invoke the branch \& cut algorithm on partially fixed problem
 
       The method presolves the given model and does branch and cut. The search
@@ -277 +276 @@
       Deletes model2
     */
-    int subBranchAndBound(CbcModel * model2,
-                          CbcModel * presolvedModel,
-                          int maximumNodes);
-    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
+  int subBranchAndBound(CbcModel *model2,
+    CbcModel *presolvedModel,
+    int maximumNodes);
+  /** \brief Invoke the branch \& cut algorithm on partially fixed problem
 
       The method creates a new model with given bounds, presolves it
@@ -295 +294 @@
 
     */
-    int subBranchAndBound(const double * lower, const double * upper,
-                          int maximumNodes);
-
-    /** \brief Process root node and return a strengthened model
+  int subBranchAndBound(const double *lower, const double *upper,
+    int maximumNodes);
+
+  /** \brief Process root node and return a strengthened model
 
       The method assumes that initialSolve() has been called to solve the
@@ -304 +303 @@
       to the strengthened model (or NULL if infeasible)
     */
-    OsiSolverInterface *  strengthenedModel();
-    /** preProcess problem - replacing solver
+  OsiSolverInterface *strengthenedModel();
+  /** preProcess problem - replacing solver
         If makeEquality true then <= cliques converted to ==.
         Presolve will be done numberPasses times.
@@ -314 +313 @@
         if 2 add slacks to get sos (but only if looks plausible) and keep sos info
     */
-    CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5,
-                                int tuning = 5);
-    /** Does postprocessing - original solver back.
+  CglPreProcess *preProcess(int makeEquality = 0, int numberPasses = 5,
+    int tuning = 5);
+  /** Does postprocessing - original solver back.
         User has to delete process */
-    void postProcess(CglPreProcess * process);
+  void postProcess(CglPreProcess *process);
 #endif
-    /// Returns CglPreProcess used before branch and bound
-    inline CglPreProcess * preProcess( ) const
-    { return preProcess_;}
-    /// Set CglPreProcess used before branch and bound
-    inline void setPreProcess(CglPreProcess * preProcess)
-    { preProcess_ = preProcess;}
-    /// Adds an update information object
-    void addUpdateInformation(const CbcObjectUpdateData & data);
-    /** Do one node - broken out for clarity?
+  /// Returns CglPreProcess used before branch and bound
+  inline CglPreProcess *preProcess() const
+  {
+    return preProcess_;
+  }
+  /// Set CglPreProcess used before branch and bound
+  inline void setPreProcess(CglPreProcess *preProcess)
+  {
+    preProcess_ = preProcess;
+  }
+  /// Adds an update information object
+  void addUpdateInformation(const CbcObjectUpdateData &data);
+  /** Do one node - broken out for clarity?
         also for parallel (when baseModel!=this)
         Returns 1 if solution found
@@ -334 +337 @@
         newNode NULL if no new node created
     */
-    int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);
+  int doOneNode(CbcModel *baseModel, CbcNode *&node, CbcNode *&newNode);
 
 public:
-    /** \brief Reoptimise an LP relaxation
+  /** \brief Reoptimise an LP relaxation
 
       Invoke the solver's %resolve() method.
@@ -350 +353 @@
       returns 1 feasible, 0 infeasible, -1 feasible but skip cuts
     */
-    int resolve(CbcNodeInfo * parent, int whereFrom,
-                double * saveSolution = NULL,
-                double * saveLower = NULL,
-                double * saveUpper = NULL);
-    /// Make given rows (L or G) into global cuts and remove from lp
-    void makeGlobalCuts(int numberRows, const int * which);
-    /// Make given cut into a global cut
-    int makeGlobalCut(const OsiRowCut * cut);
-    /// Make given cut into a global cut
-    int makeGlobalCut(const OsiRowCut & cut);
-    /// Make given column cut into a global cut
-    void makeGlobalCut(const OsiColCut * cut);
-    /// Make given column cut into a global cut
-    void makeGlobalCut(const OsiColCut & cut);
-    /// Make partial cut into a global cut and save
-  void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL);
-    /// Make partial cuts into global cuts
-    void makeGlobalCuts();
-    /// Which cut generator generated this cut
-    inline const int * whichGenerator() const
-    { return whichGenerator_;}
-    //@}
-
-    /** \name Presolve methods */
-    //@{
-
-    /** Identify cliques and construct corresponding objects.
+  int resolve(CbcNodeInfo *parent, int whereFrom,
+    double *saveSolution = NULL,
+    double *saveLower = NULL,
+    double *saveUpper = NULL);
+  /// Make given rows (L or G) into global cuts and remove from lp
+  void makeGlobalCuts(int numberRows, const int *which);
+  /// Make given cut into a global cut
+  int makeGlobalCut(const OsiRowCut *cut);
+  /// Make given cut into a global cut
+  int makeGlobalCut(const OsiRowCut &cut);
+  /// Make given column cut into a global cut
+  void makeGlobalCut(const OsiColCut *cut);
+  /// Make given column cut into a global cut
+  void makeGlobalCut(const OsiColCut &cut);
+  /// Make partial cut into a global cut and save
+  void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver = NULL);
+  /// Make partial cuts into global cuts
+  void makeGlobalCuts();
+  /// Which cut generator generated this cut
+  inline const int *whichGenerator() const
+  {
+    return whichGenerator_;
+  }
+  //@}
+
+  /** \name Presolve methods */
+  //@{
+
+  /** Identify cliques and construct corresponding objects.
 
         Find cliques with size in the range
@@ -387 +392 @@
         If priorities exist, clique priority is set to the default.
     */
-    CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
-                           int lessThanThis, int defaultValue = 1000);
-
-    /** Do integer presolve, creating a new (presolved) model.
+  CbcModel *findCliques(bool makeEquality, int atLeastThisMany,
+    int lessThanThis, int defaultValue = 1000);
+
+  /** Do integer presolve, creating a new (presolved) model.
 
       Returns the new model, or NULL if feasibility is lost.
@@ -398 +403 @@
             the original problem at the end. So this is very preliminary.
      */
-    CbcModel * integerPresolve(bool weak = false);
-
-    /** Do integer presolve, modifying the current model.
+  CbcModel *integerPresolve(bool weak = false);
+
+  /** Do integer presolve, modifying the current model.
 
         Returns true if the model remains feasible after presolve.
     */
-    bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false);
-
-
-    /// Put back information into the original model after integer presolve.
-    void originalModel(CbcModel * presolvedModel, bool weak);
-
-    /** \brief For variables involved in VUB constraints, see if we can tighten
+  bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak = false);
+
+  /// Put back information into the original model after integer presolve.
+  void originalModel(CbcModel *presolvedModel, bool weak);
+
+  /** \brief For variables involved in VUB constraints, see if we can tighten
            bounds by solving lp's
 
@@ -430 +434 @@
         constraint with \p useCutoff as a bound.
     */
-    bool tightenVubs(int type, bool allowMultipleBinary = false,
-                     double useCutoff = 1.0e50);
-
-    /** \brief For variables involved in VUB constraints, see if we can tighten
+  bool tightenVubs(int type, bool allowMultipleBinary = false,
+    double useCutoff = 1.0e50);
+
+  /** \brief For variables involved in VUB constraints, see if we can tighten
            bounds by solving lp's
 
       This version is just handed a list of variables to be processed.
     */
-    bool tightenVubs(int numberVubs, const int * which,
-                     double useCutoff = 1.0e50);
-    /**
+  bool tightenVubs(int numberVubs, const int *which,
+    double useCutoff = 1.0e50);
+  /**
       Analyze problem to find a minimum change in the objective function.
     */
-    void analyzeObjective();
-    /** Returns postProcessed solution in solver(called from event handler)
+  void analyzeObjective();
+  /** Returns postProcessed solution in solver(called from event handler)
      Normally used for integer solution (not really tested otherwise)
     solutionType 1 is best integer so far, 0 is current solution 
     (may not be integer) */
-    const OsiSolverInterface * postProcessedSolver(int solutionType=1);
-
-    /**
+  const OsiSolverInterface *postProcessedSolver(int solutionType = 1);
+
+  /**
       Add additional integers.
     */
-    void AddIntegers();
-    /**
+  void AddIntegers();
+  /**
       Save copy of the model.
     */
-    void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);
-    /**
+  void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible);
+  /**
       Flip direction of optimization on all models
     */
-    void flipModel();
-    /**
+  void flipModel();
+  /**
        Clean model i.e. make SOS/integer variables exactly at bound if needed.
        Only if moreSpecialOptions2_ 15 bit set (32768) as there is a small 
@@ -475 +479 @@
        cleanVariables array will be used if exists
      */
-     int cleanBounds(OsiSolverInterface * solver, char * cleanVariables);
-     /// Sets up cleanVariables array (i.e. ones to be careful about)
-     char * setupCleanVariables();
-    //@}
-
-    /** \name Object manipulation routines
+  int cleanBounds(OsiSolverInterface *solver, char *cleanVariables);
+  /// Sets up cleanVariables array (i.e. ones to be careful about)
+  char *setupCleanVariables();
+  //@}
+
+  /** \name Object manipulation routines
 
       See OsiObject for an explanation of `object' in the context of CbcModel.
     */
-    //@{
-
-    /// Get the number of objects
-    inline int numberObjects() const {
-        return numberObjects_;
-    }
-    /// Set the number of objects
-    inline void setNumberObjects(int number) {
-        numberObjects_ = number;
-    }
-
-    /// Get the array of objects
-    inline OsiObject ** objects() const {
-        return object_;
-    }
-
-    /// Get the specified object
-    const inline OsiObject * object(int which) const {
-        return object_[which];
-    }
-    /// Get the specified object
-    inline OsiObject * modifiableObject(int which) const {
-        return object_[which];
-    }
-
-    void setOptionalInteger(int index);
-
-    /// Delete all object information (and just back to integers if true)
-    void deleteObjects(bool findIntegers = true);
-
-    /** Add in object information.
+  //@{
+
+  /// Get the number of objects
+  inline int numberObjects() const
+  {
+    return numberObjects_;
+  }
+  /// Set the number of objects
+  inline void setNumberObjects(int number)
+  {
+    numberObjects_ = number;
+  }
+
+  /// Get the array of objects
+  inline OsiObject **objects() const
+  {
+    return object_;
+  }
+
+  /// Get the specified object
+  const inline OsiObject *object(int which) const
+  {
+    return object_[which];
+  }
+  /// Get the specified object
+  inline OsiObject *modifiableObject(int which) const
+  {
+    return object_[which];
+  }
+
+  void setOptionalInteger(int index);
+
+  /// Delete all object information (and just back to integers if true)
+  void deleteObjects(bool findIntegers = true);
+
+  /** Add in object information.
 
       Objects are cloned; the owner can delete the originals.
     */
-    void addObjects(int numberObjects, OsiObject ** objects);
-
-    /** Add in object information.
+  void addObjects(int numberObjects, OsiObject **objects);
+
+  /** Add in object information.
 
       Objects are cloned; the owner can delete the originals.
     */
-    void addObjects(int numberObjects, CbcObject ** objects);
-
-    /// Ensure attached objects point to this model.
-    void synchronizeModel() ;
-
-    /** \brief Identify integer variables and create corresponding objects.
+  void addObjects(int numberObjects, CbcObject **objects);
+
+  /// Ensure attached objects point to this model.
+  void synchronizeModel();
+
+  /** \brief Identify integer variables and create corresponding objects.
 
       Record integer variables and create an CbcSimpleInteger object for each
@@ -538 +547 @@
     */
 
-    void findIntegers(bool startAgain, int type = 0);
-    /** Add SOS info to solver -
+  void findIntegers(bool startAgain, int type = 0);
+  /** Add SOS info to solver -
         Overwrites SOS information in solver with information
         in CbcModel.  Has no effect with some solvers. 
         Also updates integer info. */
-    void addSOSEtcToSolver();
+  void addSOSEtcToSolver();
 
 #ifdef SWITCH_VARIABLES
-    /// Convert Dynamic to Switching 
-    int findSwitching();
-    /// Fix associated variables
-    int fixAssociated(OsiSolverInterface * solver,int cleanBasis);
-    /// Debug associated variables
-    int checkAssociated(const OsiSolverInterface * solver,
-                        const double * solution, int printLevel);
+  /// Convert Dynamic to Switching
+  int findSwitching();
+  /// Fix associated variables
+  int fixAssociated(OsiSolverInterface *solver, int cleanBasis);
+  /// Debug associated variables
+  int checkAssociated(const OsiSolverInterface *solver,
+    const double *solution, int printLevel);
 #endif
-    //@}
-
-    //---------------------------------------------------------------------------
-
-    /**@name Parameter set/get methods
+  //@}
+
+  //---------------------------------------------------------------------------
+
+  /**@name Parameter set/get methods
 
        The set methods return true if the parameter was set to the given value,
@@ -566 +575 @@
 
     */
-    //@{
-    /// Set an integer parameter
-    inline bool setIntParam(CbcIntParam key, int value) {
-        intParam_[key] = value;
-        return true;
-    }
-    /// Set a double parameter
-    inline bool setDblParam(CbcDblParam key, double value) {
-        dblParam_[key] = value;
-        return true;
-    }
-    /// Get an integer parameter
-    inline int getIntParam(CbcIntParam key) const {
-        return intParam_[key];
-    }
-    /// Get a double parameter
-    inline double getDblParam(CbcDblParam key) const {
-        return dblParam_[key];
-    }
-    /*! \brief Set cutoff bound on the objective function.
+  //@{
+  /// Set an integer parameter
+  inline bool setIntParam(CbcIntParam key, int value)
+  {
+    intParam_[key] = value;
+    return true;
+  }
+  /// Set a double parameter
+  inline bool setDblParam(CbcDblParam key, double value)
+  {
+    dblParam_[key] = value;
+    return true;
+  }
+  /// Get an integer parameter
+  inline int getIntParam(CbcIntParam key) const
+  {
+    return intParam_[key];
+  }
+  /// Get a double parameter
+  inline double getDblParam(CbcDblParam key) const
+  {
+    return dblParam_[key];
+  }
+  /*! \brief Set cutoff bound on the objective function.
 
       When using strict comparison, the bound is adjusted by a tolerance to
       avoid accidentally cutting off the optimal solution.
     */
-    void setCutoff(double value) ;
-
-    /// Get the cutoff bound on the objective function - always as minimize
-    inline double getCutoff() const { //double value ;
-        //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
-        //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
-        return dblParam_[CbcCurrentCutoff];
-    }
-
-    /// Set the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
-    inline bool setMaximumNodes( int value) {
-        return setIntParam(CbcMaxNumNode, value);
-    }
-
-    /// Get the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
-    inline int getMaximumNodes() const {
-        return getIntParam(CbcMaxNumNode);
-    }
-
-    /** Set the
+  void setCutoff(double value);
+
+  /// Get the cutoff bound on the objective function - always as minimize
+  inline double getCutoff() const
+  { //double value ;
+    //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
+    //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
+    return dblParam_[CbcCurrentCutoff];
+  }
+
+  /// Set the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
+  inline bool setMaximumNodes(int value)
+  {
+    return setIntParam(CbcMaxNumNode, value);
+  }
+
+  /// Get the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
+  inline int getMaximumNodes() const
+  {
+    return getIntParam(CbcMaxNumNode);
+  }
+
+  /** Set the
         \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
         desired.
     */
-    inline bool setMaximumSolutions( int value) {
-        return setIntParam(CbcMaxNumSol, value);
-    }
-    /** Get the
+  inline bool setMaximumSolutions(int value)
+  {
+    return setIntParam(CbcMaxNumSol, value);
+  }
+  /** Get the
         \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
         desired.
     */
-    inline int getMaximumSolutions() const {
-        return getIntParam(CbcMaxNumSol);
-    }
-    /// Set the printing mode
-    inline bool setPrintingMode( int value) {
-        return setIntParam(CbcPrinting, value);
-    }
-
-    /// Get the printing mode
-    inline int getPrintingMode() const {
-        return getIntParam(CbcPrinting);
-    }
-
-    /** Set the
+  inline int getMaximumSolutions() const
+  {
+    return getIntParam(CbcMaxNumSol);
+  }
+  /// Set the printing mode
+  inline bool setPrintingMode(int value)
+  {
+    return setIntParam(CbcPrinting, value);
+  }
+
+  /// Get the printing mode
+  inline int getPrintingMode() const
+  {
+    return getIntParam(CbcPrinting);
+  }
+
+  /** Set the
         \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
         desired.
     */
-    inline bool setMaximumSeconds( double value) {
-        return setDblParam(CbcMaximumSeconds, value);
-    }
-    /** Get the
+  inline bool setMaximumSeconds(double value)
+  {
+    return setDblParam(CbcMaximumSeconds, value);
+  }
+  /** Get the
         \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
         desired.
     */
-    inline double getMaximumSeconds() const {
-        return getDblParam(CbcMaximumSeconds);
-    }
-    /// Current time since start of branchAndbound
-    double getCurrentSeconds() const ;
-
-    /// Return true if maximum time reached
-    bool maximumSecondsReached() const ;
-
-    /** Set the
+  inline double getMaximumSeconds() const
+  {
+    return getDblParam(CbcMaximumSeconds);
+  }
+  /// Current time since start of branchAndbound
+  double getCurrentSeconds() const;
+
+  /// Return true if maximum time reached
+  bool maximumSecondsReached() const;
+
+  /** Set the
       \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
     */
-    inline bool setIntegerTolerance( double value) {
-        return setDblParam(CbcIntegerTolerance, value);
-    }
-    /** Get the
+  inline bool setIntegerTolerance(double value)
+  {
+    return setDblParam(CbcIntegerTolerance, value);
+  }
+  /** Get the
       \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
     */
-    inline double getIntegerTolerance() const {
-        return getDblParam(CbcIntegerTolerance);
-    }
-
-    /** Set the
+  inline double getIntegerTolerance() const
+  {
+    return getDblParam(CbcIntegerTolerance);
+  }
+
+  /** Set the
         \link CbcModel::CbcInfeasibilityWeight
           weight per integer infeasibility \endlink
     */
-    inline bool setInfeasibilityWeight( double value) {
-        return setDblParam(CbcInfeasibilityWeight, value);
-    }
-    /** Get the
+  inline bool setInfeasibilityWeight(double value)
+  {
+    return setDblParam(CbcInfeasibilityWeight, value);
+  }
+  /** Get the
         \link CbcModel::CbcInfeasibilityWeight
           weight per integer infeasibility \endlink
     */
-    inline double getInfeasibilityWeight() const {
-        return getDblParam(CbcInfeasibilityWeight);
-    }
-
-    /** Set the \link CbcModel::CbcAllowableGap allowable gap \endlink
+  inline double getInfeasibilityWeight() const
+  {
+    return getDblParam(CbcInfeasibilityWeight);
+  }
+
+  /** Set the \link CbcModel::CbcAllowableGap allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline bool setAllowableGap( double value) {
-        return setDblParam(CbcAllowableGap, value);
-    }
-    /** Get the \link CbcModel::CbcAllowableGap allowable gap \endlink
+  inline bool setAllowableGap(double value)
+  {
+    return setDblParam(CbcAllowableGap, value);
+  }
+  /** Get the \link CbcModel::CbcAllowableGap allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline double getAllowableGap() const {
-        return getDblParam(CbcAllowableGap);
-    }
-
-    /** Set the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
+  inline double getAllowableGap() const
+  {
+    return getDblParam(CbcAllowableGap);
+  }
+
+  /** Set the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline bool setAllowableFractionGap( double value) {
-        return setDblParam(CbcAllowableFractionGap, value);
-    }
-    /** Get the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
+  inline bool setAllowableFractionGap(double value)
+  {
+    return setDblParam(CbcAllowableFractionGap, value);
+  }
+  /** Get the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline double getAllowableFractionGap() const {
-        return getDblParam(CbcAllowableFractionGap);
-    }
-    /** Set the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
+  inline double getAllowableFractionGap() const
+  {
+    return getDblParam(CbcAllowableFractionGap);
+  }
+  /** Set the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline bool setAllowablePercentageGap( double value) {
-        return setDblParam(CbcAllowableFractionGap, value*0.01);
-    }
-    /** Get the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
+  inline bool setAllowablePercentageGap(double value)
+  {
+    return setDblParam(CbcAllowableFractionGap, value * 0.01);
+  }
+  /** Get the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline double getAllowablePercentageGap() const {
-        return 100.0*getDblParam(CbcAllowableFractionGap);
-    }
-    /** Set the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
+  inline double getAllowablePercentageGap() const
+  {
+    return 100.0 * getDblParam(CbcAllowableFractionGap);
+  }
+  /** Set the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline bool setHeuristicGap( double value) {
-        return setDblParam(CbcHeuristicGap, value);
-    }
-    /** Get the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
+  inline bool setHeuristicGap(double value)
+  {
+    return setDblParam(CbcHeuristicGap, value);
+  }
+  /** Get the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline double getHeuristicGap() const {
-        return getDblParam(CbcHeuristicGap);
-    }
-
-    /** Set the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
+  inline double getHeuristicGap() const
+  {
+    return getDblParam(CbcHeuristicGap);
+  }
+
+  /** Set the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline bool setHeuristicFractionGap( double value) {
-        return setDblParam(CbcHeuristicFractionGap, value);
-    }
-    /** Get the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
+  inline bool setHeuristicFractionGap(double value)
+  {
+    return setDblParam(CbcHeuristicFractionGap, value);
+  }
+  /** Get the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
         between the best known solution and the best possible solution.
     */
-    inline double getHeuristicFractionGap() const {
-        return getDblParam(CbcHeuristicFractionGap);
-    }
-    /** Set the
+  inline double getHeuristicFractionGap() const
+  {
+    return getDblParam(CbcHeuristicFractionGap);
+  }
+  /** Set the
         \link CbcModel::CbcCutoffIncrement  \endlink
         desired.
     */
-    inline bool setCutoffIncrement( double value) {
-        return setDblParam(CbcCutoffIncrement, value);
-    }
-    /** Get the
+  inline bool setCutoffIncrement(double value)
+  {
+    return setDblParam(CbcCutoffIncrement, value);
+  }
+  /** Get the
         \link CbcModel::CbcCutoffIncrement  \endlink
         desired.
     */
-    inline double getCutoffIncrement() const {
-        return getDblParam(CbcCutoffIncrement);
-    }
-    /// See if can stop on gap
-    bool canStopOnGap() const;
-
-    /** Pass in target solution and optional priorities.
+  inline double getCutoffIncrement() const
+  {
+    return getDblParam(CbcCutoffIncrement);
+  }
+  /// See if can stop on gap
+  bool canStopOnGap() const;
+
+  /** Pass in target solution and optional priorities.
         If priorities then >0 means only branch if incorrect
         while <0 means branch even if correct. +1 or -1 are
         highest priority */
-    void setHotstartSolution(const double * solution, const int * priorities = NULL) ;
-
-    /// Set the minimum drop to continue cuts
-    inline void setMinimumDrop(double value) {
-        minimumDrop_ = value;
-    }
-    /// Get the minimum drop to continue cuts
-    inline double getMinimumDrop() const {
-        return minimumDrop_;
-    }
-
-    /** Set the maximum number of cut passes at root node (default 20)
+  void setHotstartSolution(const double *solution, const int *priorities = NULL);
+
+  /// Set the minimum drop to continue cuts
+  inline void setMinimumDrop(double value)
+  {
+    minimumDrop_ = value;
+  }
+  /// Get the minimum drop to continue cuts
+  inline double getMinimumDrop() const
+  {
+    return minimumDrop_;
+  }
+
+  /** Set the maximum number of cut passes at root node (default 20)
         Minimum drop can also be used for fine tuning */
-    inline void setMaximumCutPassesAtRoot(int value) {
-        maximumCutPassesAtRoot_ = value;
-    }
-    /** Get the maximum number of cut passes at root node */
-    inline int getMaximumCutPassesAtRoot() const {
-        return maximumCutPassesAtRoot_;
-    }
-
-    /** Set the maximum number of cut passes at other nodes (default 10)
+  inline void setMaximumCutPassesAtRoot(int value)
+  {
+    maximumCutPassesAtRoot_ = value;
+  }
+  /** Get the maximum number of cut passes at root node */
+  inline int getMaximumCutPassesAtRoot() const
+  {
+    return maximumCutPassesAtRoot_;
+  }
+
+  /** Set the maximum number of cut passes at other nodes (default 10)
         Minimum drop can also be used for fine tuning */
-    inline void setMaximumCutPasses(int value) {
-        maximumCutPasses_ = value;
-    }
-    /** Get the maximum number of cut passes at other nodes (default 10) */
-    inline int getMaximumCutPasses() const {
-        return maximumCutPasses_;
-    }
-    /** Get current cut pass number in this round of cuts.
+  inline void setMaximumCutPasses(int value)
+  {
+    maximumCutPasses_ = value;
+  }
+  /** Get the maximum number of cut passes at other nodes (default 10) */
+  inline int getMaximumCutPasses() const
+  {
+    return maximumCutPasses_;
+  }
+  /** Get current cut pass number in this round of cuts.
         (1 is first pass) */
-    inline int getCurrentPassNumber() const {
-        return currentPassNumber_;
-    }
-    /** Set current cut pass number in this round of cuts.
+  inline int getCurrentPassNumber() const
+  {
+    return currentPassNumber_;
+  }
+  /** Set current cut pass number in this round of cuts.
         (1 is first pass) */
-    inline void setCurrentPassNumber(int value) {
-        currentPassNumber_ = value;
-    }
-
-    /** Set the maximum number of candidates to be evaluated for strong
+  inline void setCurrentPassNumber(int value)
+  {
+    currentPassNumber_ = value;
+  }
+
+  /** Set the maximum number of candidates to be evaluated for strong
       branching.
 
       A value of 0 disables strong branching.
     */
-    void setNumberStrong(int number);
-    /** Get the maximum number of candidates to be evaluated for strong
+  void setNumberStrong(int number);
+  /** Get the maximum number of candidates to be evaluated for strong
       branching.
     */
-    inline int numberStrong() const {
-        return numberStrong_;
-    }
-    /** Set global preferred way to branch
+  inline int numberStrong() const
+  {
+    return numberStrong_;
+  }
+  /** Set global preferred way to branch
         -1 down, +1 up, 0 no preference */
-    inline void setPreferredWay(int value) {
-        preferredWay_ = value;
-    }
-    /** Get the preferred way to branch (default 0) */
-    inline int getPreferredWay() const {
-        return preferredWay_;
-    }
-    /// Get at which depths to do cuts
-    inline int whenCuts() const {
-        return whenCuts_;
-    }
-    /// Set at which depths to do cuts
-    inline void setWhenCuts(int value) {
-        whenCuts_ = value;
-    }
-    /** Return true if we want to do cuts
+  inline void setPreferredWay(int value)
+  {
+    preferredWay_ = value;
+  }
+  /** Get the preferred way to branch (default 0) */
+  inline int getPreferredWay() const
+  {
+    return preferredWay_;
+  }
+  /// Get at which depths to do cuts
+  inline int whenCuts() const
+  {
+    return whenCuts_;
+  }
+  /// Set at which depths to do cuts
+  inline void setWhenCuts(int value)
+  {
+    whenCuts_ = value;
+  }
+  /** Return true if we want to do cuts
         If allowForTopOfTree zero then just does on multiples of depth
         if 1 then allows for doing at top of tree
         if 2 then says if cuts allowed anywhere apart from root
     */
-    bool doCutsNow(int allowForTopOfTree) const;
-
-    /** Set the number of branches before pseudo costs believed
+  bool doCutsNow(int allowForTopOfTree) const;
+
+  /** Set the number of branches before pseudo costs believed
         in dynamic strong branching.
 
       A value of 0 disables dynamic strong branching.
     */
-    void setNumberBeforeTrust(int number);
-    /** get the number of branches before pseudo costs believed
+  void setNumberBeforeTrust(int number);
+  /** get the number of branches before pseudo costs believed
         in dynamic strong branching. */
-    inline int numberBeforeTrust() const {
-        return numberBeforeTrust_;
-    }
-    /** Set the number of variables for which to compute penalties
+  inline int numberBeforeTrust() const
+  {
+    return numberBeforeTrust_;
+  }
+  /** Set the number of variables for which to compute penalties
         in dynamic strong branching.
 
       A value of 0 disables penalties.
     */
-    void setNumberPenalties(int number);
-    /** get the number of variables for which to compute penalties
+  void setNumberPenalties(int number);
+  /** get the number of variables for which to compute penalties
         in dynamic strong branching. */
-    inline int numberPenalties() const {
-        return numberPenalties_;
-    }
-    /// Pointer to top of tree
-    inline const CbcFullNodeInfo * topOfTree() const
-    { return topOfTree_;}
-    /// Number of analyze iterations to do
-    inline void setNumberAnalyzeIterations(int number) {
-        numberAnalyzeIterations_ = number;
-    }
-    inline int numberAnalyzeIterations() const {
-        return numberAnalyzeIterations_;
-    }
-    /** Get scale factor to make penalties match strong.
+  inline int numberPenalties() const
+  {
+    return numberPenalties_;
+  }
+  /// Pointer to top of tree
+  inline const CbcFullNodeInfo *topOfTree() const
+  {
+    return topOfTree_;
+  }
+  /// Number of analyze iterations to do
+  inline void setNumberAnalyzeIterations(int number)
+  {
+    numberAnalyzeIterations_ = number;
+  }
+  inline int numberAnalyzeIterations() const
+  {
+    return numberAnalyzeIterations_;
+  }
+  /** Get scale factor to make penalties match strong.
         Should/will be computed */
-    inline double penaltyScaleFactor() const {
-        return penaltyScaleFactor_;
-    }
-    /** Set scale factor to make penalties match strong.
+  inline double penaltyScaleFactor() const
+  {
+    return penaltyScaleFactor_;
+  }
+  /** Set scale factor to make penalties match strong.
         Should/will be computed */
-    void setPenaltyScaleFactor(double value);
-    /** Problem type as set by user or found by analysis.  This will be extended
+  void setPenaltyScaleFactor(double value);
+  /** Problem type as set by user or found by analysis.  This will be extended
         0 - not known
         1 - Set partitioning <=
@@ -888 +946 @@
         4 - all +- 1 or all +1 and odd
     */
-    void inline setProblemType(int number) {
-        problemType_ = number;
-    }
-    inline int problemType() const {
-        return problemType_;
-    }
-    /// Current depth
-    inline int currentDepth() const {
-        return currentDepth_;
-    }
-
-    /// Set how often to scan global cuts
-    void setHowOftenGlobalScan(int number);
-    /// Get how often to scan global cuts
-    inline int howOftenGlobalScan() const {
-        return howOftenGlobalScan_;
-    }
-    /// Original columns as created by integerPresolve or preprocessing
-    inline int * originalColumns() const {
-        return originalColumns_;
-    }
-    /// Set original columns as created by preprocessing
-    void setOriginalColumns(const int * originalColumns,
-                            int numberGood=COIN_INT_MAX) ;
-    /// Create conflict cut (well - most of)
-    OsiRowCut * conflictCut(const OsiSolverInterface * solver, bool & localCuts);
-
-    /** Set the print frequency.
+  void inline setProblemType(int number)
+  {
+    problemType_ = number;
+  }
+  inline int problemType() const
+  {
+    return problemType_;
+  }
+  /// Current depth
+  inline int currentDepth() const
+  {
+    return currentDepth_;
+  }
+
+  /// Set how often to scan global cuts
+  void setHowOftenGlobalScan(int number);
+  /// Get how often to scan global cuts
+  inline int howOftenGlobalScan() const
+  {
+    return howOftenGlobalScan_;
+  }
+  /// Original columns as created by integerPresolve or preprocessing
+  inline int *originalColumns() const
+  {
+    return originalColumns_;
+  }
+  /// Set original columns as created by preprocessing
+  void setOriginalColumns(const int *originalColumns,
+    int numberGood = COIN_INT_MAX);
+  /// Create conflict cut (well - most of)
+  OsiRowCut *conflictCut(const OsiSolverInterface *solver, bool &localCuts);
+
+  /** Set the print frequency.
 
       Controls the number of nodes evaluated between status prints.
@@ -922 +985 @@
       Print frequency has very slight overhead if small.
     */
-    inline void setPrintFrequency(int number) {
-        printFrequency_ = number;
-    }
-    /// Get the print frequency
-    inline int printFrequency() const {
-        return printFrequency_;
-    }
-    //@}
-
-    //---------------------------------------------------------------------------
-    ///@name Methods returning info on how the solution process terminated
-    //@{
-    /// Are there a numerical difficulties?
-    bool isAbandoned() const;
-    /// Is optimality proven?
-    bool isProvenOptimal() const;
-    /// Is  infeasiblity proven (or none better than cutoff)?
-    bool isProvenInfeasible() const;
-    /// Was continuous solution unbounded
-    bool isContinuousUnbounded() const;
-    /// Was continuous solution unbounded
-    bool isProvenDualInfeasible() const;
-    /// Node limit reached?
-    bool isNodeLimitReached() const;
-    /// Time limit reached?
-    bool isSecondsLimitReached() const;
-    /// Solution limit reached?
-    bool isSolutionLimitReached() const;
-    /// Get how many iterations it took to solve the problem.
-    inline int getIterationCount() const {
-        return numberIterations_;
-    }
-    /// Increment how many iterations it took to solve the problem.
-    inline void incrementIterationCount(int value) {
-        numberIterations_ += value;
-    }
-    /// Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP).
-    inline int getNodeCount() const {
-        return numberNodes_;
-    }
-    /// Increment how many nodes it took to solve the problem.
-    inline void incrementNodeCount(int value) {
-        numberNodes_ += value;
-    }
-    /// Get how many Nodes were enumerated in complete fathoming B&B inside CLP
-    inline int getExtraNodeCount() const {
-       return numberExtraNodes_;
-    }
-    /// Get how many times complete fathoming B&B was done
-    inline int getFathomCount() const {
-       return numberFathoms_;
-    }
-    /** Final status of problem
+  inline void setPrintFrequency(int number)
+  {
+    printFrequency_ = number;
+  }
+  /// Get the print frequency
+  inline int printFrequency() const
+  {
+    return printFrequency_;
+  }
+  //@}
+
+  //---------------------------------------------------------------------------
+  ///@name Methods returning info on how the solution process terminated
+  //@{
+  /// Are there a numerical difficulties?
+  bool isAbandoned() const;
+  /// Is optimality proven?
+  bool isProvenOptimal() const;
+  /// Is  infeasiblity proven (or none better than cutoff)?
+  bool isProvenInfeasible() const;
+  /// Was continuous solution unbounded
+  bool isContinuousUnbounded() const;
+  /// Was continuous solution unbounded
+  bool isProvenDualInfeasible() const;
+  /// Node limit reached?
+  bool isNodeLimitReached() const;
+  /// Time limit reached?
+  bool isSecondsLimitReached() const;
+  /// Solution limit reached?
+  bool isSolutionLimitReached() const;
+  /// Get how many iterations it took to solve the problem.
+  inline int getIterationCount() const
+  {
+    return numberIterations_;
+  }
+  /// Increment how many iterations it took to solve the problem.
+  inline void incrementIterationCount(int value)
+  {
+    numberIterations_ += value;
+  }
+  /// Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP).
+  inline int getNodeCount() const
+  {
+    return numberNodes_;
+  }
+  /// Increment how many nodes it took to solve the problem.
+  inline void incrementNodeCount(int value)
+  {
+    numberNodes_ += value;
+  }
+  /// Get how many Nodes were enumerated in complete fathoming B&B inside CLP
+  inline int getExtraNodeCount() const
+  {
+    return numberExtraNodes_;
+  }
+  /// Get how many times complete fathoming B&B was done
+  inline int getFathomCount() const
+  {
+    return numberFathoms_;
+  }
+  /** Final status of problem
         Some of these can be found out by is...... functions
         -1 before branchAndBound
@@ -983 +1054 @@
         (5 event user programmed event occurred)
     */
-    inline int status() const {
-        return status_;
-    }
-    inline void setProblemStatus(int value) {
-        status_ = value;
-    }
-    /** Secondary status of problem
+  inline int status() const
+  {
+    return status_;
+  }
+  inline void setProblemStatus(int value)
+  {
+    status_ = value;
+  }
+  /** Secondary status of problem
         -1 unset (status_ will also be -1)
         0 search completed with solution
@@ -1001 +1074 @@
         8 stopped on iteration limit
     */
-    inline int secondaryStatus() const {
-        return secondaryStatus_;
-    }
-    inline void setSecondaryStatus(int value) {
-        secondaryStatus_ = value;
-    }
-    /// Are there numerical difficulties (for initialSolve) ?
-    bool isInitialSolveAbandoned() const ;
-    /// Is optimality proven (for initialSolve) ?
-    bool isInitialSolveProvenOptimal() const ;
-    /// Is primal infeasiblity proven (for initialSolve) ?
-    bool isInitialSolveProvenPrimalInfeasible() const ;
-    /// Is dual infeasiblity proven (for initialSolve) ?
-    bool isInitialSolveProvenDualInfeasible() const ;
-
-    //@}
-
-    //---------------------------------------------------------------------------
-    /**@name Problem information methods
+  inline int secondaryStatus() const
+  {
+    return secondaryStatus_;
+  }
+  inline void setSecondaryStatus(int value)
+  {
+    secondaryStatus_ = value;
+  }
+  /// Are there numerical difficulties (for initialSolve) ?
+  bool isInitialSolveAbandoned() const;
+  /// Is optimality proven (for initialSolve) ?
+  bool isInitialSolveProvenOptimal() const;
+  /// Is primal infeasiblity proven (for initialSolve) ?
+  bool isInitialSolveProvenPrimalInfeasible() const;
+  /// Is dual infeasiblity proven (for initialSolve) ?
+  bool isInitialSolveProvenDualInfeasible() const;
+
+  //@}
+
+  //---------------------------------------------------------------------------
+  /**@name Problem information methods
 
        These methods call the solver's query routines to return
@@ -1030 +1105 @@
        long as the data is unchanged and the solver is not called.
     */
-    //@{
-    /// Number of rows in continuous (root) problem.
-    inline int numberRowsAtContinuous() const {
-        return numberRowsAtContinuous_;
-    }
-
-    /// Get number of columns
-    inline int getNumCols() const {
-        return solver_->getNumCols();
-    }
-
-    /// Get number of rows
-    inline int getNumRows() const {
-        return solver_->getNumRows();
-    }
-
-    /// Get number of nonzero elements
-    inline CoinBigIndex getNumElements() const {
-        return solver_->getNumElements();
-    }
-
-    /// Number of integers in problem
-    inline int numberIntegers() const {
-        return numberIntegers_;
-    }
-    // Integer variables
-    inline const int * integerVariable() const {
-        return integerVariable_;
-    }
-    /// Whether or not integer
-    inline char integerType(int i) const {
-        assert (integerInfo_);
-        assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
-        return integerInfo_[i];
-    }
-    /// Whether or not integer
-    inline const char * integerType() const {
-        return integerInfo_;
-    }
-
-    /// Get pointer to array[getNumCols()] of column lower bounds
-    inline const double * getColLower() const {
-        return solver_->getColLower();
-    }
-
-    /// Get pointer to array[getNumCols()] of column upper bounds
-    inline const double * getColUpper() const {
-        return solver_->getColUpper();
-    }
-
-    /** Get pointer to array[getNumRows()] of row constraint senses.
+  //@{
+  /// Number of rows in continuous (root) problem.
+  inline int numberRowsAtContinuous() const
+  {
+    return numberRowsAtContinuous_;
+  }
+
+  /// Get number of columns
+  inline int getNumCols() const
+  {
+    return solver_->getNumCols();
+  }
+
+  /// Get number of rows
+  inline int getNumRows() const
+  {
+    return solver_->getNumRows();
+  }
+
+  /// Get number of nonzero elements
+  inline CoinBigIndex getNumElements() const
+  {
+    return solver_->getNumElements();
+  }
+
+  /// Number of integers in problem
+  inline int numberIntegers() const
+  {
+    return numberIntegers_;
+  }
+  // Integer variables
+  inline const int *integerVariable() const
+  {
+    return integerVariable_;
+  }
+  /// Whether or not integer
+  inline char integerType(int i) const
+  {
+    assert(integerInfo_);
+    assert(integerInfo_[i] == 0 || integerInfo_[i] == 1);
+    return integerInfo_[i];
+  }
+  /// Whether or not integer
+  inline const char *integerType() const
+  {
+    return integerInfo_;
+  }
+
+  /// Get pointer to array[getNumCols()] of column lower bounds
+  inline const double *getColLower() const
+  {
+    return solver_->getColLower();
+  }
+
+  /// Get pointer to array[getNumCols()] of column upper bounds
+  inline const double *getColUpper() const
+  {
+    return solver_->getColUpper();
+  }
+
+  /** Get pointer to array[getNumRows()] of row constraint senses.
         <ul>
         <li>'L': <= constraint
@@ -1089 +1174 @@
         </ul>
     */
-    inline const char * getRowSense() const {
-        return solver_->getRowSense();
-    }
-
-    /** Get pointer to array[getNumRows()] of rows right-hand sides
+  inline const char *getRowSense() const
+  {
+    return solver_->getRowSense();
+  }
+
+  /** Get pointer to array[getNumRows()] of rows right-hand sides
         <ul>
         <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
@@ -1101 +1187 @@
         </ul>
     */
-    inline const double * getRightHandSide() const {
-        return solver_->getRightHandSide();
-    }
-
-    /** Get pointer to array[getNumRows()] of row ranges.
+  inline const double *getRightHandSide() const
+  {
+    return solver_->getRightHandSide();
+  }
+
+  /** Get pointer to array[getNumRows()] of row ranges.
         <ul>
         <li> if rowsense()[i] == 'R' then
@@ -1113 +1200 @@
         </ul>
     */
-    inline const double * getRowRange() const {
-        return solver_->getRowRange();
-    }
-
-    /// Get pointer to array[getNumRows()] of row lower bounds
-    inline const double * getRowLower() const {
-        return solver_->getRowLower();
-    }
-
-    /// Get pointer to array[getNumRows()] of row upper bounds
-    inline const double * getRowUpper() const {
-        return solver_->getRowUpper();
-    }
-
-    /// Get pointer to array[getNumCols()] of objective function coefficients
-    inline const double * getObjCoefficients() const {
-        return solver_->getObjCoefficients();
-    }
-
-    /// Get objective function sense (1 for min (default), -1 for max)
-    inline double getObjSense() const {
-        //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
-        return dblParam_[CbcOptimizationDirection];
-    }
-
-    /// Return true if variable is continuous
-    inline bool isContinuous(int colIndex) const {
-        return solver_->isContinuous(colIndex);
-    }
-
-    /// Return true if variable is binary
-    inline bool isBinary(int colIndex) const {
-        return solver_->isBinary(colIndex);
-    }
-
-    /** Return true if column is integer.
+  inline const double *getRowRange() const
+  {
+    return solver_->getRowRange();
+  }
+
+  /// Get pointer to array[getNumRows()] of row lower bounds
+  inline const double *getRowLower() const
+  {
+    return solver_->getRowLower();
+  }
+
+  /// Get pointer to array[getNumRows()] of row upper bounds
+  inline const double *getRowUpper() const
+  {
+    return solver_->getRowUpper();
+  }
+
+  /// Get pointer to array[getNumCols()] of objective function coefficients
+  inline const double *getObjCoefficients() const
+  {
+    return solver_->getObjCoefficients();
+  }
+
+  /// Get objective function sense (1 for min (default), -1 for max)
+  inline double getObjSense() const
+  {
+    //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
+    return dblParam_[CbcOptimizationDirection];
+  }
+
+  /// Return true if variable is continuous
+  inline bool isContinuous(int colIndex) const
+  {
+    return solver_->isContinuous(colIndex);
+  }
+
+  /// Return true if variable is binary
+  inline bool isBinary(int colIndex) const
+  {
+    return solver_->isBinary(colIndex);
+  }
+
+  /** Return true if column is integer.
         Note: This function returns true if the the column
         is binary or a general integer.
     */
-    inline bool isInteger(int colIndex) const {
-        return solver_->isInteger(colIndex);
-    }
-
-    /// Return true if variable is general integer
-    inline bool isIntegerNonBinary(int colIndex) const {
-        return solver_->isIntegerNonBinary(colIndex);
-    }
-
-    /// Return true if variable is binary and not fixed at either bound
-    inline bool isFreeBinary(int colIndex) const {
-        return solver_->isFreeBinary(colIndex) ;
-    }
-
-    /// Get pointer to row-wise copy of matrix
-    inline const CoinPackedMatrix * getMatrixByRow() const {
-        return solver_->getMatrixByRow();
-    }
-
-    /// Get pointer to column-wise copy of matrix
-    inline const CoinPackedMatrix * getMatrixByCol() const {
-        return solver_->getMatrixByCol();
-    }
-
-    /// Get solver's value for infinity
-    inline double getInfinity() const {
-        return solver_->getInfinity();
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
-    inline const double * getCbcColLower() const {
-        return cbcColLower_;
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
-    inline const double * getCbcColUpper() const {
-        return cbcColUpper_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
-    inline const double * getCbcRowLower() const {
-        return cbcRowLower_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
-    inline const double * getCbcRowUpper() const {
-        return cbcRowUpper_;
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
-    inline const double * getCbcColSolution() const {
-        return cbcColSolution_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of dual prices
-    inline const double * getCbcRowPrice() const {
-        return cbcRowPrice_;
-    }
-    /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
-    inline const double * getCbcReducedCost() const {
-        return cbcReducedCost_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
-    inline const double * getCbcRowActivity() const {
-        return cbcRowActivity_;
-    }
-    //@}
-
-
-    /**@name Methods related to querying the solution */
-    //@{
-    /// Holds solution at continuous (after cuts if branchAndBound called)
-    inline double * continuousSolution() const {
-        return continuousSolution_;
-    }
-    /** Array marked whenever a solution is found if non-zero.
+  inline bool isInteger(int colIndex) const
+  {
+    return solver_->isInteger(colIndex);
+  }
+
+  /// Return true if variable is general integer
+  inline bool isIntegerNonBinary(int colIndex) const
+  {
+    return solver_->isIntegerNonBinary(colIndex);
+  }
+
+  /// Return true if variable is binary and not fixed at either bound
+  inline bool isFreeBinary(int colIndex) const
+  {
+    return solver_->isFreeBinary(colIndex);
+  }
+
+  /// Get pointer to row-wise copy of matrix
+  inline const CoinPackedMatrix *getMatrixByRow() const
+  {
+    return solver_->getMatrixByRow();
+  }
+
+  /// Get pointer to column-wise copy of matrix
+  inline const CoinPackedMatrix *getMatrixByCol() const
+  {
+    return solver_->getMatrixByCol();
+  }
+
+  /// Get solver's value for infinity
+  inline double getInfinity() const
+  {
+    return solver_->getInfinity();
+  }
+  /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
+  inline const double *getCbcColLower() const
+  {
+    return cbcColLower_;
+  }
+  /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
+  inline const double *getCbcColUpper() const
+  {
+    return cbcColUpper_;
+  }
+  /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
+  inline const double *getCbcRowLower() const
+  {
+    return cbcRowLower_;
+  }
+  /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
+  inline const double *getCbcRowUpper() const
+  {
+    return cbcRowUpper_;
+  }
+  /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
+  inline const double *getCbcColSolution() const
+  {
+    return cbcColSolution_;
+  }
+  /// Get pointer to array[getNumRows()] (for speed) of dual prices
+  inline const double *getCbcRowPrice() const
+  {
+    return cbcRowPrice_;
+  }
+  /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
+  inline const double *getCbcReducedCost() const
+  {
+    return cbcReducedCost_;
+  }
+  /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
+  inline const double *getCbcRowActivity() const
+  {
+    return cbcRowActivity_;
+  }
+  //@}
+
+  /**@name Methods related to querying the solution */
+  //@{
+  /// Holds solution at continuous (after cuts if branchAndBound called)
+  inline double *continuousSolution() const
+  {
+    return continuousSolution_;
+  }
+  /** Array marked whenever a solution is found if non-zero.
         Code marks if heuristic returns better so heuristic
         need only mark if it wants to on solutions which
         are worse than current */
-    inline int * usedInSolution() const {
-        return usedInSolution_;
-    }
-    /// Increases usedInSolution for nonzeros
-    void incrementUsed(const double * solution);
-    /// Record a new incumbent solution and update objectiveValue
-    void setBestSolution(CBC_Message how,
-                         double & objectiveValue, const double *solution,
-                         int fixVariables = 0);
-    /// Just update objectiveValue
-    void setBestObjectiveValue( double objectiveValue);
-    /// Deals with event handler and solution
-    CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
-            double objValue,
-            const double * solution);
-
-    /** Call this to really test if a valid solution can be feasible
+  inline int *usedInSolution() const
+  {
+    return usedInSolution_;
+  }
+  /// Increases usedInSolution for nonzeros
+  void incrementUsed(const double *solution);
+  /// Record a new incumbent solution and update objectiveValue
+  void setBestSolution(CBC_Message how,
+    double &objectiveValue, const double *solution,
+    int fixVariables = 0);
+  /// Just update objectiveValue
+  void setBestObjectiveValue(double objectiveValue);
+  /// Deals with event handler and solution
+  CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
+    double objValue,
+    const double *solution);
+
+  /** Call this to really test if a valid solution can be feasible
         Solution is number columns in size.
         If fixVariables true then bounds of continuous solver updated.
@@ -1248 +1357 @@
         virtual so user can override
     */
-    virtual double checkSolution(double cutoff, double * solution,
-                         int fixVariables, double originalObjValue);
-    /** Test the current solution for feasiblility.
+  virtual double checkSolution(double cutoff, double *solution,
+    int fixVariables, double originalObjValue);
+  /** Test the current solution for feasiblility.
 
       Scan all objects for indications of infeasibility. This is broken down
@@ -1256 +1365 @@
       and all other reports of infeasibility (\p numberObjectInfeasibilities).
     */
-    bool feasibleSolution(int & numberIntegerInfeasibilities,
-                          int & numberObjectInfeasibilities) const;
-
-    /** Solution to the most recent lp relaxation.
+  bool feasibleSolution(int &numberIntegerInfeasibilities,
+    int &numberObjectInfeasibilities) const;
+
+  /** Solution to the most recent lp relaxation.
 
       The solver's solution to the most recent lp relaxation.
     */
 
-    inline double * currentSolution() const {
-        return currentSolution_;
-    }
-    /** For testing infeasibilities - will point to
+  inline double *currentSolution() const
+  {
+    return currentSolution_;
+  }
+  /** For testing infeasibilities - will point to
         currentSolution_ or solver-->getColSolution()
     */
-    inline const double * testSolution() const {
-        return testSolution_;
-    }
-    inline void setTestSolution(const double * solution) {
-        testSolution_ = solution;
-    }
-    /// Make sure region there and optionally copy solution
-    void reserveCurrentSolution(const double * solution = NULL);
-
-    /// Get pointer to array[getNumCols()] of primal solution vector
-    inline const double * getColSolution() const {
-        return solver_->getColSolution();
-    }
-
-    /// Get pointer to array[getNumRows()] of dual prices
-    inline const double * getRowPrice() const {
-        return solver_->getRowPrice();
-    }
-
-    /// Get a pointer to array[getNumCols()] of reduced costs
-    inline const double * getReducedCost() const {
-        return solver_->getReducedCost();
-    }
-
-    /// Get pointer to array[getNumRows()] of row activity levels.
-    inline const double * getRowActivity() const {
-        return solver_->getRowActivity();
-    }
-
-    /// Get current objective function value
-    inline double getCurrentObjValue() const {
-        return dblParam_[CbcCurrentObjectiveValue];
-    }
-    /// Get current minimization objective function value
-    inline double getCurrentMinimizationObjValue() const {
-        return dblParam_[CbcCurrentMinimizationObjectiveValue];
-    }
-
-    /// Get best objective function value as minimization
-    inline double getMinimizationObjValue() const {
-        return bestObjective_;
-    }
-    /// Set best objective function value as minimization
-    inline void setMinimizationObjValue(double value) {
-        bestObjective_ = value;
-    }
-
-    /// Get best objective function value
-    inline double getObjValue() const {
-        return bestObjective_ * solver_->getObjSense() ;
-    }
-    /** Get best possible objective function value.
+  inline const double *testSolution() const
+  {
+    return testSolution_;
+  }
+  inline void setTestSolution(const double *solution)
+  {
+    testSolution_ = solution;
+  }
+  /// Make sure region there and optionally copy solution
+  void reserveCurrentSolution(const double *solution = NULL);
+
+  /// Get pointer to array[getNumCols()] of primal solution vector
+  inline const double *getColSolution() const
+  {
+    return solver_->getColSolution();
+  }
+
+  /// Get pointer to array[getNumRows()] of dual prices
+  inline const double *getRowPrice() const
+  {
+    return solver_->getRowPrice();
+  }
+
+  /// Get a pointer to array[getNumCols()] of reduced costs
+  inline const double *getReducedCost() const
+  {
+    return solver_->getReducedCost();
+  }
+
+  /// Get pointer to array[getNumRows()] of row activity levels.
+  inline const double *getRowActivity() const
+  {
+    return solver_->getRowActivity();
+  }
+
+  /// Get current objective function value
+  inline double getCurrentObjValue() const
+  {
+    return dblParam_[CbcCurrentObjectiveValue];
+  }
+  /// Get current minimization objective function value
+  inline double getCurrentMinimizationObjValue() const
+  {
+    return dblParam_[CbcCurrentMinimizationObjectiveValue];
+  }
+
+  /// Get best objective function value as minimization
+  inline double getMinimizationObjValue() const
+  {
+    return bestObjective_;
+  }
+  /// Set best objective function value as minimization
+  inline void setMinimizationObjValue(double value)
+  {
+    bestObjective_ = value;
+  }
+
+  /// Get best objective function value
+  inline double getObjValue() const
+  {
+    return bestObjective_ * solver_->getObjSense();
+  }
+  /** Get best possible objective function value.
         This is better of best possible left on tree
         and best solution found.
         If called from within branch and cut may be optimistic.
     */
-    double getBestPossibleObjValue() const;
-    /// Set best objective function value
-    inline void setObjValue(double value) {
-        bestObjective_ = value * solver_->getObjSense() ;
-    }
-    /// Get solver objective function value (as minimization)
-    inline double getSolverObjValue() const {
-        return solver_->getObjValue() * solver_->getObjSense() ;
-    }
-
-    /** The best solution to the integer programming problem.
+  double getBestPossibleObjValue() const;
+  /// Set best objective function value
+  inline void setObjValue(double value)
+  {
+    bestObjective_ = value * solver_->getObjSense();
+  }
+  /// Get solver objective function value (as minimization)
+  inline double getSolverObjValue() const
+  {
+    return solver_->getObjValue() * solver_->getObjSense();
+  }
+
+  /** The best solution to the integer programming problem.
 
       The best solution to the integer programming problem found during
@@ -1342 +1465 @@
     */
 
-    inline double * bestSolution() const {
-        return bestSolution_;
-    }
-    /** User callable setBestSolution.
+  inline double *bestSolution() const
+  {
+    return bestSolution_;
+  }
+  /** User callable setBestSolution.
         If check false does not check valid
         If true then sees if feasible and warns if objective value
@@ -1351 +1475 @@
         If check true then does not save solution if not feasible
     */
-    void setBestSolution(const double * solution, int numberColumns,
-                         double objectiveValue, bool check = false);
-
-    /// Get number of solutions
-    inline int getSolutionCount() const {
-        return numberSolutions_;
-    }
-
-    /// Set number of solutions (so heuristics will be different)
-    inline void setSolutionCount(int value) {
-        numberSolutions_ = value;
-    }
-    /// Number of saved solutions (including best)
-    int numberSavedSolutions() const;
-    /// Maximum number of extra saved solutions
-    inline int maximumSavedSolutions() const {
-        return maximumSavedSolutions_;
-    }
-    /// Set maximum number of extra saved solutions
-    void setMaximumSavedSolutions(int value);
-    /// Return a saved solution (0==best) - NULL if off end
-    const double * savedSolution(int which) const;
-    /// Return a saved solution objective (0==best) - COIN_DBL_MAX if off end
-    double savedSolutionObjective(int which) const;
-    /// Delete a saved solution and move others up
-    void deleteSavedSolution(int which);
-
-    /** Current phase (so heuristics etc etc can find out).
+  void setBestSolution(const double *solution, int numberColumns,
+    double objectiveValue, bool check = false);
+
+  /// Get number of solutions
+  inline int getSolutionCount() const
+  {
+    return numberSolutions_;
+  }
+
+  /// Set number of solutions (so heuristics will be different)
+  inline void setSolutionCount(int value)
+  {
+    numberSolutions_ = value;
+  }
+  /// Number of saved solutions (including best)
+  int numberSavedSolutions() const;
+  /// Maximum number of extra saved solutions
+  inline int maximumSavedSolutions() const
+  {
+    return maximumSavedSolutions_;
+  }
+  /// Set maximum number of extra saved solutions
+  void setMaximumSavedSolutions(int value);
+  /// Return a saved solution (0==best) - NULL if off end
+  const double *savedSolution(int which) const;
+  /// Return a saved solution objective (0==best) - COIN_DBL_MAX if off end
+  double savedSolutionObjective(int which) const;
+  /// Delete a saved solution and move others up
+  void deleteSavedSolution(int which);
+
+  /** Current phase (so heuristics etc etc can find out).
         0 - initial solve
         1 - solve with cuts at root
@@ -1386 +1513 @@
         5 - at end of search
     */
-    inline int phase() const {
-        return phase_;
-    }
-
-    /// Get number of heuristic solutions
-    inline int getNumberHeuristicSolutions() const {
-        return numberHeuristicSolutions_;
-    }
-    /// Set number of heuristic solutions
-    inline void setNumberHeuristicSolutions(int value) {
-        numberHeuristicSolutions_ = value;
-    }
-
-    /// Set objective function sense (1 for min (default), -1 for max,)
-    inline void setObjSense(double s) {
-        dblParam_[CbcOptimizationDirection] = s;
-        solver_->setObjSense(s);
-    }
-
-    /// Value of objective at continuous
-    inline double getContinuousObjective() const {
-        return originalContinuousObjective_;
-    }
-    inline void setContinuousObjective(double value) {
-        originalContinuousObjective_ = value;
-    }
-    /// Number of infeasibilities at continuous
-    inline int getContinuousInfeasibilities() const {
-        return continuousInfeasibilities_;
-    }
-    inline void setContinuousInfeasibilities(int value) {
-        continuousInfeasibilities_ = value;
-    }
-    /// Value of objective after root node cuts added
-    inline double rootObjectiveAfterCuts() const {
-        return continuousObjective_;
-    }
-    /// Sum of Changes to objective by first solve
-    inline double sumChangeObjective() const {
-        return sumChangeObjective1_;
-    }
-    /** Number of times global cuts violated.  When global cut pool then this
+  inline int phase() const
+  {
+    return phase_;
+  }
+
+  /// Get number of heuristic solutions
+  inline int getNumberHeuristicSolutions() const
+  {
+    return numberHeuristicSolutions_;
+  }
+  /// Set number of heuristic solutions
+  inline void setNumberHeuristicSolutions(int value)
+  {
+    numberHeuristicSolutions_ = value;
+  }
+
+  /// Set objective function sense (1 for min (default), -1 for max,)
+  inline void setObjSense(double s)
+  {
+    dblParam_[CbcOptimizationDirection] = s;
+    solver_->setObjSense(s);
+  }
+
+  /// Value of objective at continuous
+  inline double getContinuousObjective() const
+  {
+    return originalContinuousObjective_;
+  }
+  inline void setContinuousObjective(double value)
+  {
+    originalContinuousObjective_ = value;
+  }
+  /// Number of infeasibilities at continuous
+  inline int getContinuousInfeasibilities() const
+  {
+    return continuousInfeasibilities_;
+  }
+  inline void setContinuousInfeasibilities(int value)
+  {
+    continuousInfeasibilities_ = value;
+  }
+  /// Value of objective after root node cuts added
+  inline double rootObjectiveAfterCuts() const
+  {
+    return continuousObjective_;
+  }
+  /// Sum of Changes to objective by first solve
+  inline double sumChangeObjective() const
+  {
+    return sumChangeObjective1_;
+  }
+  /** Number of times global cuts violated.  When global cut pool then this
         should be kept for each cut and type of cut */
-    inline int numberGlobalViolations() const {
-        return numberGlobalViolations_;
-    }
-    inline void clearNumberGlobalViolations() {
-        numberGlobalViolations_ = 0;
-    }
-    /// Whether to force a resolve after takeOffCuts
-    inline bool resolveAfterTakeOffCuts() const {
-        return resolveAfterTakeOffCuts_;
-    }
-    inline void setResolveAfterTakeOffCuts(bool yesNo) {
-        resolveAfterTakeOffCuts_ = yesNo;
-    }
-    /// Maximum number of rows
-    inline int maximumRows() const {
-        return maximumRows_;
-    }
-    /// Work basis for temporary use
-    inline CoinWarmStartBasis & workingBasis() {
-        return workingBasis_;
-    }
-    /// Get number of "iterations" to stop after
-    inline int getStopNumberIterations() const {
-        return stopNumberIterations_;
-    }
-    /// Set number of "iterations" to stop after
-    inline void setStopNumberIterations(int value) {
-        stopNumberIterations_ = value;
-    }
-    /// A pointer to model from CbcHeuristic
-    inline CbcModel * heuristicModel() const
-    { return heuristicModel_;}
-    /// Set a pointer to model from CbcHeuristic
-    inline void setHeuristicModel(CbcModel * model)
-    { heuristicModel_ = model;}
-    //@}
-
-    /** \name Node selection */
-    //@{
-    // Comparison functions (which may be overridden by inheritance)
-    inline CbcCompareBase * nodeComparison() const {
-        return nodeCompare_;
-    }
-    void setNodeComparison(CbcCompareBase * compare);
-    void setNodeComparison(CbcCompareBase & compare);
-    //@}
-
-    /** \name Problem feasibility checking */
-    //@{
-    // Feasibility functions (which may be overridden by inheritance)
-    inline CbcFeasibilityBase * problemFeasibility() const {
-        return problemFeasibility_;
-    }
-    void setProblemFeasibility(CbcFeasibilityBase * feasibility);
-    void setProblemFeasibility(CbcFeasibilityBase & feasibility);
-    //@}
-
-    /** \name Tree methods and subtree methods */
-    //@{
-    /// Tree method e.g. heap (which may be overridden by inheritance)
-    inline CbcTree * tree() const {
-        return tree_;
-    }
-    /// For modifying tree handling (original is cloned)
-    void passInTreeHandler(CbcTree & tree);
-    /** For passing in an CbcModel to do a sub Tree (with derived tree handlers).
+  inline int numberGlobalViolations() const
+  {
+    return numberGlobalViolations_;
+  }
+  inline void clearNumberGlobalViolations()
+  {
+    numberGlobalViolations_ = 0;
+  }
+  /// Whether to force a resolve after takeOffCuts
+  inline bool resolveAfterTakeOffCuts() const
+  {
+    return resolveAfterTakeOffCuts_;
+  }
+  inline void setResolveAfterTakeOffCuts(bool yesNo)
+  {
+    resolveAfterTakeOffCuts_ = yesNo;
+  }
+  /// Maximum number of rows
+  inline int maximumRows() const
+  {
+    return maximumRows_;
+  }
+  /// Work basis for temporary use
+  inline CoinWarmStartBasis &workingBasis()
+  {
+    return workingBasis_;
+  }
+  /// Get number of "iterations" to stop after
+  inline int getStopNumberIterations() const
+  {
+    return stopNumberIterations_;
+  }
+  /// Set number of "iterations" to stop after
+  inline void setStopNumberIterations(int value)
+  {
+    stopNumberIterations_ = value;
+  }
+  /// A pointer to model from CbcHeuristic
+  inline CbcModel *heuristicModel() const
+  {
+    return heuristicModel_;
+  }
+  /// Set a pointer to model from CbcHeuristic
+  inline void setHeuristicModel(CbcModel *model)
+  {
+    heuristicModel_ = model;
+  }
+  //@}
+
+  /** \name Node selection */
+  //@{
+  // Comparison functions (which may be overridden by inheritance)
+  inline CbcCompareBase *nodeComparison() const
+  {
+    return nodeCompare_;
+  }
+  void setNodeComparison(CbcCompareBase *compare);
+  void setNodeComparison(CbcCompareBase &compare);
+  //@}
+
+  /** \name Problem feasibility checking */
+  //@{
+  // Feasibility functions (which may be overridden by inheritance)
+  inline CbcFeasibilityBase *problemFeasibility() const
+  {
+    return problemFeasibility_;
+  }
+  void setProblemFeasibility(CbcFeasibilityBase *feasibility);
+  void setProblemFeasibility(CbcFeasibilityBase &feasibility);
+  //@}
+
+  /** \name Tree methods and subtree methods */
+  //@{
+  /// Tree method e.g. heap (which may be overridden by inheritance)
+  inline CbcTree *tree() const
+  {
+    return tree_;
+  }
+  /// For modifying tree handling (original is cloned)
+  void passInTreeHandler(CbcTree &tree);
+  /** For passing in an CbcModel to do a sub Tree (with derived tree handlers).
         Passed in model must exist for duration of branch and bound
     */
-    void passInSubTreeModel(CbcModel & model);
-    /** For retrieving a copy of subtree model with given OsiSolver.
+  void passInSubTreeModel(CbcModel &model);
+  /** For retrieving a copy of subtree model with given OsiSolver.
         If no subtree model will use self (up to user to reset cutoff etc).
         If solver NULL uses current
     */
-    CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
-    /// Returns number of times any subtree stopped on nodes, time etc
-    inline int numberStoppedSubTrees() const {
-        return numberStoppedSubTrees_;
-    }
-    /// Says a sub tree was stopped
-    inline void incrementSubTreeStopped() {
-        numberStoppedSubTrees_++;
-    }
-    /** Whether to automatically do presolve before branch and bound (subTrees).
+  CbcModel *subTreeModel(OsiSolverInterface *solver = NULL) const;
+  /// Returns number of times any subtree stopped on nodes, time etc
+  inline int numberStoppedSubTrees() const
+  {
+    return numberStoppedSubTrees_;
+  }
+  /// Says a sub tree was stopped
+  inline void incrementSubTreeStopped()
+  {
+    numberStoppedSubTrees_++;
+  }
+  /** Whether to automatically do presolve before branch and bound (subTrees).
         0 - no
         1 - ordinary presolve
         2 - integer presolve (dodgy)
     */
-    inline int typePresolve() const {
-        return presolve_;
-    }
-    inline void setTypePresolve(int value) {
-        presolve_ = value;
-    }
-
-    //@}
-
-    /** \name Branching Decisions
+  inline int typePresolve() const
+  {
+    return presolve_;
+  }
+  inline void setTypePresolve(int value)
+  {
+    presolve_ = value;
+  }
+
+  //@}
+
+  /** \name Branching Decisions
 
       See the CbcBranchDecision class for additional information.
     */
-    //@{
-
-    /// Get the current branching decision method.
-    inline CbcBranchDecision * branchingMethod() const {
-        return branchingMethod_;
-    }
-    /// Set the branching decision method.
-    inline void setBranchingMethod(CbcBranchDecision * method) {
-        delete branchingMethod_;
-        branchingMethod_ = method->clone();
-    }
-    /** Set the branching method
+  //@{
+
+  /// Get the current branching decision method.
+  inline CbcBranchDecision *branchingMethod() const
+  {
+    return branchingMethod_;
+  }
+  /// Set the branching decision method.
+  inline void setBranchingMethod(CbcBranchDecision *method)
+  {
+    delete branchingMethod_;
+    branchingMethod_ = method->clone();
+  }
+  /** Set the branching method
 
       \overload
     */
-    inline void setBranchingMethod(CbcBranchDecision & method) {
-        delete branchingMethod_;
-        branchingMethod_ = method.clone();
-    }
-    /// Get the current cut modifier method
-    inline CbcCutModifier * cutModifier() const {
-        return cutModifier_;
-    }
-    /// Set the cut modifier method
-    void setCutModifier(CbcCutModifier * modifier);
-    /** Set the cut modifier method
+  inline void setBranchingMethod(CbcBranchDecision &method)
+  {
+    delete branchingMethod_;
+    branchingMethod_ = method.clone();
+  }
+  /// Get the current cut modifier method
+  inline CbcCutModifier *cutModifier() const
+  {
+    return cutModifier_;
+  }
+  /// Set the cut modifier method
+  void setCutModifier(CbcCutModifier *modifier);
+  /** Set the cut modifier method
 
       \overload
     */
-    void setCutModifier(CbcCutModifier & modifier);
-    //@}
-
-    /** \name Row (constraint) and Column (variable) cut generation */
-    //@{
-
-    /** State of search
+  void setCutModifier(CbcCutModifier &modifier);
+  //@}
+
+  /** \name Row (constraint) and Column (variable) cut generation */
+  //@{
+
+  /** State of search
         0 - no solution
         1 - only heuristic solutions
@@ -1570 +1730 @@
         3 - no solution but many nodes
     */
-    inline int stateOfSearch() const {
-        return stateOfSearch_;
-    }
-    inline void setStateOfSearch(int state) {
-        stateOfSearch_ = state;
-    }
-    /// Strategy worked out - mainly at root node for use by CbcNode
-    inline int searchStrategy() const {
-        return searchStrategy_;
-    }
-    /// Set strategy worked out - mainly at root node for use by CbcNode
-    inline void setSearchStrategy(int value) {
-        searchStrategy_ = value;
-    }
-    /// Stong branching strategy
-    inline int strongStrategy() const {
-        return strongStrategy_;
-    }
-    /// Set strong branching strategy
-    inline void setStrongStrategy(int value) {
-        strongStrategy_ = value;
-    }
-
-    /// Get the number of cut generators
-    inline int numberCutGenerators() const {
-        return numberCutGenerators_;
-    }
-    /// Get the list of cut generators
-    inline CbcCutGenerator ** cutGenerators() const {
-        return generator_;
-    }
-    ///Get the specified cut generator
-    inline CbcCutGenerator * cutGenerator(int i) const {
-        return generator_[i];
-    }
-    ///Get the specified cut generator before any changes
-    inline CbcCutGenerator * virginCutGenerator(int i) const {
-        return virginGenerator_[i];
-    }
-    /** Add one generator - up to user to delete generators.
+  inline int stateOfSearch() const
+  {
+    return stateOfSearch_;
+  }
+  inline void setStateOfSearch(int state)
+  {
+    stateOfSearch_ = state;
+  }
+  /// Strategy worked out - mainly at root node for use by CbcNode
+  inline int searchStrategy() const
+  {
+    return searchStrategy_;
+  }
+  /// Set strategy worked out - mainly at root node for use by CbcNode
+  inline void setSearchStrategy(int value)
+  {
+    searchStrategy_ = value;
+  }
+  /// Stong branching strategy
+  inline int strongStrategy() const
+  {
+    return strongStrategy_;
+  }
+  /// Set strong branching strategy
+  inline void setStrongStrategy(int value)
+  {
+    strongStrategy_ = value;
+  }
+
+  /// Get the number of cut generators
+  inline int numberCutGenerators() const
+  {
+    return numberCutGenerators_;
+  }
+  /// Get the list of cut generators
+  inline CbcCutGenerator **cutGenerators() const
+  {
+    return generator_;
+  }
+  ///Get the specified cut generator
+  inline CbcCutGenerator *cutGenerator(int i) const
+  {
+    return generator_[i];
+  }
+  ///Get the specified cut generator before any changes
+  inline CbcCutGenerator *virginCutGenerator(int i) const
+  {
+    return virginGenerator_[i];
+  }
+  /** Add one generator - up to user to delete generators.
         howoften affects how generator is used. 0 or 1 means always,
         >1 means every that number of nodes.  Negative values have same
@@ -1617 +1787 @@
         If depth >0 overrides how often generator is called (if howOften==-1 or >0).
     */
-    void addCutGenerator(CglCutGenerator * generator,
-                         int howOften = 1, const char * name = NULL,
-                         bool normal = true, bool atSolution = false,
-                         bool infeasible = false, int howOftenInSub = -100,
-                         int whatDepth = -1, int whatDepthInSub = -1);
-//@}
-    /** \name Strategy and sub models
+  void addCutGenerator(CglCutGenerator *generator,
+    int howOften = 1, const char *name = NULL,
+    bool normal = true, bool atSolution = false,
+    bool infeasible = false, int howOftenInSub = -100,
+    int whatDepth = -1, int whatDepthInSub = -1);
+  //@}
+  /** \name Strategy and sub models
 
       See the CbcStrategy class for additional information.
     */
-    //@{
-
-    /// Get the current strategy
-    inline CbcStrategy * strategy() const {
-        return strategy_;
-    }
-    /// Set the strategy. Clones
-    void setStrategy(CbcStrategy & strategy);
-    /// Set the strategy. assigns
-    inline void setStrategy(CbcStrategy * strategy) {
-        strategy_ = strategy;
-    }
-    /// Get the current parent model
-    inline CbcModel * parentModel() const {
-        return parentModel_;
-    }
-    /// Set the parent model
-    inline void setParentModel(CbcModel & parentModel) {
-        parentModel_ = &parentModel;
-    }
-    //@}
-
-
-    /** \name Heuristics and priorities */
-    //@{
-    /*! \brief Add one heuristic - up to user to delete
+  //@{
+
+  /// Get the current strategy
+  inline CbcStrategy *strategy() const
+  {
+    return strategy_;
+  }
+  /// Set the strategy. Clones
+  void setStrategy(CbcStrategy &strategy);
+  /// Set the strategy. assigns
+  inline void setStrategy(CbcStrategy *strategy)
+  {
+    strategy_ = strategy;
+  }
+  /// Get the current parent model
+  inline CbcModel *parentModel() const
+  {
+    return parentModel_;
+  }
+  /// Set the parent model
+  inline void setParentModel(CbcModel &parentModel)
+  {
+    parentModel_ = &parentModel;
+  }
+  //@}
+
+  /** \name Heuristics and priorities */
+  //@{
+  /*! \brief Add one heuristic - up to user to delete
 
       The name is just used for print messages.
     */
-    void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
-                      int before = -1);
-    ///Get the specified heuristic
-    inline CbcHeuristic * heuristic(int i) const {
-        return heuristic_[i];
-    }
-    /// Get the number of heuristics
-    inline int numberHeuristics() const {
-        return numberHeuristics_;
-    }
-    /// Set the number of heuristics
-    inline void setNumberHeuristics(int value) {
-        numberHeuristics_ = value;
-    }
-    /// Pointer to heuristic solver which found last solution (or NULL)
-    inline CbcHeuristic * lastHeuristic() const {
-        return lastHeuristic_;
-    }
-    /// set last heuristic which found a solution
-    inline void setLastHeuristic(CbcHeuristic * last) {
-        lastHeuristic_ = last;
-    }
-
-    /** Pass in branching priorities.
+  void addHeuristic(CbcHeuristic *generator, const char *name = NULL,
+    int before = -1);
+  ///Get the specified heuristic
+  inline CbcHeuristic *heuristic(int i) const
+  {
+    return heuristic_[i];
+  }
+  /// Get the number of heuristics
+  inline int numberHeuristics() const
+  {
+    return numberHeuristics_;
+  }
+  /// Set the number of heuristics
+  inline void setNumberHeuristics(int value)
+  {
+    numberHeuristics_ = value;
+  }
+  /// Pointer to heuristic solver which found last solution (or NULL)
+  inline CbcHeuristic *lastHeuristic() const
+  {
+    return lastHeuristic_;
+  }
+  /// set last heuristic which found a solution
+  inline void setLastHeuristic(CbcHeuristic *last)
+  {
+    lastHeuristic_ = last;
+  }
+
+  /** Pass in branching priorities.
 
         If ifClique then priorities are on cliques otherwise priorities are
@@ -1697 +1875 @@
         \internal Added for Kurt Spielberg.
     */
-    void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
-
-    /// Returns priority level for an object (or 1000 if no priorities exist)
-    inline int priority(int sequence) const {
-        return object_[sequence]->priority();
-    }
-
-    /*! \brief Set an event handler
+  void passInPriorities(const int *priorities, bool ifNotSimpleIntegers);
+
+  /// Returns priority level for an object (or 1000 if no priorities exist)
+  inline int priority(int sequence) const
+  {
+    return object_[sequence]->priority();
+  }
+
+  /*! \brief Set an event handler
 
       A clone of the handler passed as a parameter is stored in CbcModel.
     */
-    void passInEventHandler(const CbcEventHandler *eventHandler) ;
-
-    /*! \brief Retrieve a pointer to the event handler */
-    inline CbcEventHandler* getEventHandler() const {
-        return (eventHandler_) ;
-    }
-
-    //@}
-
-    /**@name Setting/Accessing application data */
-    //@{
-    /** Set application data.
+  void passInEventHandler(const CbcEventHandler *eventHandler);
+
+  /*! \brief Retrieve a pointer to the event handler */
+  inline CbcEventHandler *getEventHandler() const
+  {
+    return (eventHandler_);
+  }
+
+  //@}
+
+  /**@name Setting/Accessing application data */
+  //@{
+  /** Set application data.
 
     This is a pointer that the application can store into and
@@ -1726 +1906 @@
     define and use.
     */
-    void setApplicationData (void * appData);
-
-    /// Get application data
-    void * getApplicationData() const;
-    /**
+  void setApplicationData(void *appData);
+
+  /// Get application data
+  void *getApplicationData() const;
+  /**
         For advanced applications you may wish to modify the behavior of Cbc
         e.g. if the solver is a NLP solver then you may not have an exact
@@ -1742 +1922 @@
         NOTE - characteristics are not cloned
     */
-    void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
-    /// Get solver characteristics
-    inline const OsiBabSolver * solverCharacteristics() const {
-        return solverCharacteristics_;
-    }
-    //@}
-
-    //---------------------------------------------------------------------------
-
-    /**@name Message handling etc */
-    //@{
-    /// Pass in Message handler (not deleted at end)
-    void passInMessageHandler(CoinMessageHandler * handler);
-    /// Set language
-    void newLanguage(CoinMessages::Language language);
-    inline void setLanguage(CoinMessages::Language language) {
-        newLanguage(language);
-    }
-    /// Return handler
-    inline CoinMessageHandler * messageHandler() const {
-        return handler_;
-    }
-    /// Return messages
-    inline CoinMessages & messages() {
-        return messages_;
-    }
-    /// Return pointer to messages
-    inline CoinMessages * messagesPointer() {
-        return &messages_;
-    }
-    /// Set log level
-    void setLogLevel(int value);
-    /// Get log level
-    inline int logLevel() const {
-        return handler_->logLevel();
-    }
-    /** Set flag to say if handler_ is the default handler.
+  void passInSolverCharacteristics(OsiBabSolver *solverCharacteristics);
+  /// Get solver characteristics
+  inline const OsiBabSolver *solverCharacteristics() const
+  {
+    return solverCharacteristics_;
+  }
+  //@}
+
+  //---------------------------------------------------------------------------
+
+  /**@name Message handling etc */
+  //@{
+  /// Pass in Message handler (not deleted at end)
+  void passInMessageHandler(CoinMessageHandler *handler);
+  /// Set language
+  void newLanguage(CoinMessages::Language language);
+  inline void setLanguage(CoinMessages::Language language)
+  {
+    newLanguage(language);
+  }
+  /// Return handler
+  inline CoinMessageHandler *messageHandler() const
+  {
+    return handler_;
+  }
+  /// Return messages
+  inline CoinMessages &messages()
+  {
+    return messages_;
+  }
+  /// Return pointer to messages
+  inline CoinMessages *messagesPointer()
+  {
+    return &messages_;
+  }
+  /// Set log level
+  void setLogLevel(int value);
+  /// Get log level
+  inline int logLevel() const
+  {
+    return handler_->logLevel();
+  }
+  /** Set flag to say if handler_ is the default handler.
 
       The default handler is deleted when the model is deleted. Other
       handlers (supplied by the client) will not be deleted.
     */
-    inline void setDefaultHandler(bool yesNo) {
-        defaultHandler_ = yesNo;
-    }
-    /// Check default handler
-    inline bool defaultHandler() const {
-        return defaultHandler_;
-    }
-    //@}
-    //---------------------------------------------------------------------------
-    ///@name Specialized
-    //@{
-
-    /**
+  inline void setDefaultHandler(bool yesNo)
+  {
+    defaultHandler_ = yesNo;
+  }
+  /// Check default handler
+  inline bool defaultHandler() const
+  {
+    return defaultHandler_;
+  }
+  //@}
+  //---------------------------------------------------------------------------
+  ///@name Specialized
+  //@{
+
+  /**
         Set special options
         0 bit (1) - check if cuts valid (if on debugger list)
@@ -1824 +2012 @@
         26 bit (67108864) - child model but going for complete search
     */
-    inline void setSpecialOptions(int value) {
-        specialOptions_ = value;
-    }
-    /// Get special options
-    inline int specialOptions() const {
-        return specialOptions_;
-    }
-    /// Set random seed
-    inline void setRandomSeed(int value) {
-        randomSeed_ = value;
-    }
-    /// Get random seed
-    inline int getRandomSeed() const {
-        return randomSeed_;
-    }
-    /// Set multiple root tries
-    inline void setMultipleRootTries(int value) {
-        multipleRootTries_ = value;
-    }
-    /// Get multiple root tries
-    inline int getMultipleRootTries() const {
-        return multipleRootTries_;
-    }
-    /// Tell model to stop on event
-    inline void sayEventHappened()
-    { eventHappened_=true;}
-    /// Says if normal solver i.e. has well defined CoinPackedMatrix
-    inline bool normalSolver() const {
-        return (specialOptions_&16) == 0;
-    }
-    /** Says if model is sitting there waiting for mini branch and bound to finish
+  inline void setSpecialOptions(int value)
+  {
+    specialOptions_ = value;
+  }
+  /// Get special options
+  inline int specialOptions() const
+  {
+    return specialOptions_;
+  }
+  /// Set random seed
+  inline void setRandomSeed(int value)
+  {
+    randomSeed_ = value;
+  }
+  /// Get random seed
+  inline int getRandomSeed() const
+  {
+    return randomSeed_;
+  }
+  /// Set multiple root tries
+  inline void setMultipleRootTries(int value)
+  {
+    multipleRootTries_ = value;
+  }
+  /// Get multiple root tries
+  inline int getMultipleRootTries() const
+  {
+    return multipleRootTries_;
+  }
+  /// Tell model to stop on event
+  inline void sayEventHappened()
+  {
+    eventHappened_ = true;
+  }
+  /// Says if normal solver i.e. has well defined CoinPackedMatrix
+  inline bool normalSolver() const
+  {
+    return (specialOptions_ & 16) == 0;
+  }
+  /** Says if model is sitting there waiting for mini branch and bound to finish
         This is because an event handler may only have access to parent model in
         mini branch and bound
     */
-    inline bool waitingForMiniBranchAndBound() const {
-        return (specialOptions_&1048576) != 0;
-    }
-    /** Set more special options
+  inline bool waitingForMiniBranchAndBound() const
+  {
+    return (specialOptions_ & 1048576) != 0;
+  }
+  /** Set more special options
         at present bottom 6 bits used for shadow price mode
         1024 for experimental hotstart
@@ -1884 +2082 @@
         30 bit (1073741824) - Funny SOS or similar - be careful
     */
-    inline void setMoreSpecialOptions(int value) {
-        moreSpecialOptions_ = value;
-    }
-    /// Get more special options
-    inline int moreSpecialOptions() const {
-        return moreSpecialOptions_;
-    }
-    /** Set more more special options
+  inline void setMoreSpecialOptions(int value)
+  {
+    moreSpecialOptions_ = value;
+  }
+  /// Get more special options
+  inline int moreSpecialOptions() const
+  {
+    return moreSpecialOptions_;
+  }
+  /** Set more more special options
         0 bit (1) - find switching variables
         1 bit (2) - using fake objective until solution
@@ -1906 +2106 @@
         15 bit 32768 - take care of very very small values for Integer/SOS variables
     */
-    inline void setMoreSpecialOptions2(int value) {
-        moreSpecialOptions2_ = value;
-    }
-    /// Get more special options2
-    inline int moreSpecialOptions2() const {
-        return moreSpecialOptions2_;
-    }
-    /// Set cutoff as constraint
-    inline void setCutoffAsConstraint(bool yesNo) {
-      cutoffRowNumber_ = (yesNo) ? -2 : -1;
-    }
-    /// Set time method
-    inline void setUseElapsedTime(bool yesNo) {
-        if (yesNo)
-          moreSpecialOptions_ |= 131072;
-        else
-          moreSpecialOptions_ &= ~131072;
-    }
-    /// Get time method
-    inline bool useElapsedTime() const {
-        return (moreSpecialOptions_&131072)!=0;
-    }
-    /// Get useful temporary pointer
-    inline void * temporaryPointer() const
-    { return temporaryPointer_;}
-    /// Set useful temporary pointer
-    inline void setTemporaryPointer(void * pointer)
-    { temporaryPointer_=pointer;}
-    /// Go to dantzig pivot selection if easy problem (clp only)
-    void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
-    /// Now we may not own objects - just point to solver's objects
-    inline bool ownObjects() const {
-        return ownObjects_;
-    }
-    /// Check original model before it gets messed up
-    void checkModel();
-    //@}
-    //---------------------------------------------------------------------------
-
-    ///@name Constructors and destructors etc
-    //@{
-    /// Default Constructor
-    CbcModel();
-
-    /// Constructor from solver
-    CbcModel(const OsiSolverInterface &);
-
-    /** Assign a solver to the model (model assumes ownership)
+  inline void setMoreSpecialOptions2(int value)
+  {
+    moreSpecialOptions2_ = value;
+  }
+  /// Get more special options2
+  inline int moreSpecialOptions2() const
+  {
+    return moreSpecialOptions2_;
+  }
+  /// Set cutoff as constraint
+  inline void setCutoffAsConstraint(bool yesNo)
+  {
+    cutoffRowNumber_ = (yesNo) ? -2 : -1;
+  }
+  /// Set time method
+  inline void setUseElapsedTime(bool yesNo)
+  {
+    if (yesNo)
+      moreSpecialOptions_ |= 131072;
+    else
+      moreSpecialOptions_ &= ~131072;
+  }
+  /// Get time method
+  inline bool useElapsedTime() const
+  {
+    return (moreSpecialOptions_ & 131072) != 0;
+  }
+  /// Get useful temporary pointer
+  inline void *temporaryPointer() const
+  {
+    return temporaryPointer_;
+  }
+  /// Set useful temporary pointer
+  inline void setTemporaryPointer(void *pointer)
+  {
+    temporaryPointer_ = pointer;
+  }
+  /// Go to dantzig pivot selection if easy problem (clp only)
+  void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod);
+  /// Now we may not own objects - just point to solver's objects
+  inline bool ownObjects() const
+  {
+    return ownObjects_;
+  }
+  /// Check original model before it gets messed up
+  void checkModel();
+  //@}
+  //---------------------------------------------------------------------------
+
+  ///@name Constructors and destructors etc
+  //@{
+  /// Default Constructor
+  CbcModel();
+
+  /// Constructor from solver
+  CbcModel(const OsiSolverInterface &);
+
+  /** Assign a solver to the model (model assumes ownership)
 
       On return, \p solver will be NULL.
@@ -1961 +2171 @@
         the incoming solver.
     */
-    void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
-
-    /** \brief Set ownership of solver
+  void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
+
+  /** \brief Set ownership of solver
 
       A parameter of false tells CbcModel it does not own the solver and
@@ -1974 +2184 @@
       and you want to hang on to the answer).
     */
-    inline void setModelOwnsSolver (bool ourSolver) {
-        ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
-    }
-
-    /*! \brief Get ownership of solver
+  inline void setModelOwnsSolver(bool ourSolver)
+  {
+    ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000));
+  }
+
+  /*! \brief Get ownership of solver
 
       A return value of true means that CbcModel owns the solver and will
       take responsibility for deleting it when that becomes necessary.
     */
-    inline bool modelOwnsSolver () {
-        return ((ownership_&0x80000000) != 0) ;
-    }
-
-    /** Copy constructor .
+  inline bool modelOwnsSolver()
+  {
+    return ((ownership_ & 0x80000000) != 0);
+  }
+
+  /** Copy constructor .
       If cloneHandler is true then message handler is cloned
     */
-    CbcModel(const CbcModel & rhs, bool cloneHandler = false);
-
-    /** Clone */
-    virtual CbcModel *clone (bool cloneHandler);
-
-    /// Assignment operator
-    CbcModel & operator=(const CbcModel& rhs);
-
-    /// Destructor
-    virtual ~CbcModel ();
-
-    /// Returns solver - has current state
-    inline OsiSolverInterface * solver() const {
-        return solver_;
-    }
-
-    /// Returns current solver - sets new one
-    inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
-        OsiSolverInterface * returnSolver = solver_;
-        solver_ = solver;
-        return returnSolver;
-    }
-
-    /// Returns solver with continuous state
-    inline OsiSolverInterface * continuousSolver() const {
-        return continuousSolver_;
-    }
-
-    /// Create solver with continuous state
-    inline void createContinuousSolver() {
-        continuousSolver_ = solver_->clone();
-    }
-    /// Clear solver with continuous state
-    inline void clearContinuousSolver() {
-        delete continuousSolver_;
-        continuousSolver_ = NULL;
-    }
-
-    /// A copy of the solver, taken at constructor or by saveReferenceSolver
-    inline OsiSolverInterface * referenceSolver() const {
-        return referenceSolver_;
-    }
-
-    /// Save a copy of the current solver so can be reset to
-    void saveReferenceSolver();
-
-    /** Uses a copy of reference solver to be current solver.
+  CbcModel(const CbcModel &rhs, bool cloneHandler = false);
+
+  /** Clone */
+  virtual CbcModel *clone(bool cloneHandler);
+
+  /// Assignment operator
+  CbcModel &operator=(const CbcModel &rhs);
+
+  /// Destructor
+  virtual ~CbcModel();
+
+  /// Returns solver - has current state
+  inline OsiSolverInterface *solver() const
+  {
+    return solver_;
+  }
+
+  /// Returns current solver - sets new one
+  inline OsiSolverInterface *swapSolver(OsiSolverInterface *solver)
+  {
+    OsiSolverInterface *returnSolver = solver_;
+    solver_ = solver;
+    return returnSolver;
+  }
+
+  /// Returns solver with continuous state
+  inline OsiSolverInterface *continuousSolver() const
+  {
+    return continuousSolver_;
+  }
+
+  /// Create solver with continuous state
+  inline void createContinuousSolver()
+  {
+    continuousSolver_ = solver_->clone();
+  }
+  /// Clear solver with continuous state
+  inline void clearContinuousSolver()
+  {
+    delete continuousSolver_;
+    continuousSolver_ = NULL;
+  }
+
+  /// A copy of the solver, taken at constructor or by saveReferenceSolver
+  inline OsiSolverInterface *referenceSolver() const
+  {
+    return referenceSolver_;
+  }
+
+  /// Save a copy of the current solver so can be reset to
+  void saveReferenceSolver();
+
+  /** Uses a copy of reference solver to be current solver.
         Because of possible mismatches all exotic integer information is loat
         (apart from normal information in OsiSolverInterface)
         so SOS etc and priorities will have to be redone
     */
-    void resetToReferenceSolver();
-
-    /// Clears out as much as possible (except solver)
-    void gutsOfDestructor();
-    /** Clears out enough to reset CbcModel as if no branch and bound done
+  void resetToReferenceSolver();
+
+  /// Clears out as much as possible (except solver)
+  void gutsOfDestructor();
+  /** Clears out enough to reset CbcModel as if no branch and bound done
      */
-    void gutsOfDestructor2();
-    /** Clears out enough to reset CbcModel cutoff etc
+  void gutsOfDestructor2();
+  /** Clears out enough to reset CbcModel cutoff etc
      */
-    void resetModel();
-    /** Most of copy constructor
+  void resetModel();
+  /** Most of copy constructor
         mode - 0 copy but don't delete before
                1 copy and delete before
            2 copy and delete before (but use virgin generators)
     */
-    void gutsOfCopy(const CbcModel & rhs, int mode = 0);
-    /// Move status, nodes etc etc across
-    void moveInfo(const CbcModel & rhs);
-    //@}
-
-    ///@name Multithreading
-    //@{
-    /// Indicates whether Cbc library has been compiled with multithreading support
-    static bool haveMultiThreadSupport();
-    /// Get pointer to masterthread
-    CbcThread * masterThread() const {
-        return masterThread_;
-    }
-    /// Get pointer to walkback
-    CbcNodeInfo ** walkback() const {
-        return walkback_;
-    }
-    /// Get number of threads
-    inline int getNumberThreads() const {
-        return numberThreads_;
-    }
-    /// Set number of threads
-    inline void setNumberThreads(int value) {
-        numberThreads_ = value;
-    }
-    /// Get thread mode
-    inline int getThreadMode() const {
-        return threadMode_;
-    }
-    /** Set thread mode
+  void gutsOfCopy(const CbcModel &rhs, int mode = 0);
+  /// Move status, nodes etc etc across
+  void moveInfo(const CbcModel &rhs);
+  //@}
+
+  ///@name Multithreading
+  //@{
+  /// Indicates whether Cbc library has been compiled with multithreading support
+  static bool haveMultiThreadSupport();
+  /// Get pointer to masterthread
+  CbcThread *masterThread() const
+  {
+    return masterThread_;
+  }
+  /// Get pointer to walkback
+  CbcNodeInfo **walkback() const
+  {
+    return walkback_;
+  }
+  /// Get number of threads
+  inline int getNumberThreads() const
+  {
+    return numberThreads_;
+  }
+  /// Set number of threads
+  inline void setNumberThreads(int value)
+  {
+    numberThreads_ = value;
+  }
+  /// Get thread mode
+  inline int getThreadMode() const
+  {
+    return threadMode_;
+  }
+  /** Set thread mode
         always use numberThreads for branching
         1 set then deterministic
@@ -2094 +2317 @@
         default is 0
     */
-    inline void setThreadMode(int value) {
-        threadMode_ = value;
-    }
-    /** Return
+  inline void setThreadMode(int value)
+  {
+    threadMode_ = value;
+  }
+  /** Return
         -2 if deterministic threaded and main thread
         -1 if deterministic threaded and serial thread
@@ -2103 +2327 @@
         1 if opportunistic threaded
     */
-    inline int parallelMode() const {
-        if (!numberThreads_) {
-            if ((threadMode_&1) == 0)
-                return 0;
-            else
-                return -1;
-            return 0;
-        } else {
-            if ((threadMode_&1) == 0)
-                return 1;
-            else
-                return -2;
-        }
+  inline int parallelMode() const
+  {
+    if (!numberThreads_) {
+      if ((threadMode_ & 1) == 0)
+        return 0;
+      else
+        return -1;
+      return 0;
+    } else {
+      if ((threadMode_ & 1) == 0)
+        return 1;
+      else
+        return -2;
     }
-    /// Thread stuff for master
-    inline CbcBaseModel * master() const
-    { return master_;}
-    /// From here to end of section - code in CbcThread.cpp until class changed
-    /// Returns true if locked
-    bool isLocked() const;
+  }
+  /// Thread stuff for master
+  inline CbcBaseModel *master() const
+  {
+    return master_;
+  }
+  /// From here to end of section - code in CbcThread.cpp until class changed
+  /// Returns true if locked
+  bool isLocked() const;
 #ifdef CBC_THREAD
-    /**
+  /**
        Locks a thread if parallel so that stuff like cut pool
        can be updated and/or used.
     */
-    void lockThread();
-    /**
+  void lockThread();
+  /**
        Unlocks a thread if parallel to say cut pool stuff not needed
     */
-    void unlockThread();
+  void unlockThread();
 #else
-    inline void lockThread() {}
-    inline void unlockThread() {}
+  inline void lockThread()
+  {
+  }
+  inline void unlockThread() {}
 #endif
-    /** Set information in a child
+  /** Set information in a child
         -3 pass pointer to child thread info
         -2 just stop
@@ -2144 +2373 @@
         1 delete deterministic child stuff
     */
-    void setInfoInChild(int type, CbcThread * info);
-    /** Move/copy information from one model to another
+  void setInfoInChild(int type, CbcThread *info);
+  /** Move/copy information from one model to another
         -1 - initialization
         0 - from base model
@@ -2151 +2380 @@
         2 - add in final statistics etc (and reset so can do clean destruction)
     */
-    void moveToModel(CbcModel * baseModel, int mode);
-    /// Split up nodes
-    int splitModel(int numberModels, CbcModel ** model,
-                   int numberNodes);
-    /// Start threads
-    void startSplitModel(int numberIterations);
-    /// Merge models
-    void mergeModels(int numberModel, CbcModel ** model,
-                     int numberNodes);
-    //@}
-
-    ///@name semi-private i.e. users should not use
-    //@{
-    /// Get how many Nodes it took to solve the problem.
-    int getNodeCount2() const {
-        return numberNodes2_;
-    }
-    /// Set pointers for speed
-    void setPointers(const OsiSolverInterface * solver);
-    /** Perform reduced cost fixing
+  void moveToModel(CbcModel *baseModel, int mode);
+  /// Split up nodes
+  int splitModel(int numberModels, CbcModel **model,
+    int numberNodes);
+  /// Start threads
+  void startSplitModel(int numberIterations);
+  /// Merge models
+  void mergeModels(int numberModel, CbcModel **model,
+    int numberNodes);
+  //@}
+
+  ///@name semi-private i.e. users should not use
+  //@{
+  /// Get how many Nodes it took to solve the problem.
+  int getNodeCount2() const
+  {
+    return numberNodes2_;
+  }
+  /// Set pointers for speed
+  void setPointers(const OsiSolverInterface *solver);
+  /** Perform reduced cost fixing
 
       Fixes integer variables at their current value based on reduced cost
       penalties.  Returns number fixed
     */
-    int reducedCostFix() ;
-    /** Makes all handlers same.  If makeDefault 1 then makes top level
+  int reducedCostFix();
+  /** Makes all handlers same.  If makeDefault 1 then makes top level
         default and rest point to that.  If 2 then each is copy
     */
-    void synchronizeHandlers(int makeDefault);
-    /// Save a solution to saved list
-    void saveExtraSolution(const double * solution, double objectiveValue);
-    /// Save a solution to best and move current to saved
-    void saveBestSolution(const double * solution, double objectiveValue);
-    /// Delete best and saved solutions
-    void deleteSolutions();
-    /// Encapsulates solver resolve
-    int resolve(OsiSolverInterface * solver);
+  void synchronizeHandlers(int makeDefault);
+  /// Save a solution to saved list
+  void saveExtraSolution(const double *solution, double objectiveValue);
+  /// Save a solution to best and move current to saved
+  void saveBestSolution(const double *solution, double objectiveValue);
+  /// Delete best and saved solutions
+  void deleteSolutions();
+  /// Encapsulates solver resolve
+  int resolve(OsiSolverInterface *solver);
 #ifdef CLP_RESOLVE
-    /// Special purpose resolve
-    int resolveClp(OsiClpSolverInterface * solver, int type);
+  /// Special purpose resolve
+  int resolveClp(OsiClpSolverInterface *solver, int type);
 #endif
 
-    /** Encapsulates choosing a variable -
+  /** Encapsulates choosing a variable -
         anyAction -2, infeasible (-1 round again), 0 done
     */
-    int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
-                     CbcNode * oldNode, OsiCuts & cuts,
-                     bool & resolved, CoinWarmStartBasis *lastws,
-                     const double * lowerBefore, const double * upperBefore,
-                     OsiSolverBranch * & branches);
-    int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
-
-    /** Return an empty basis object of the specified size
+  int chooseBranch(CbcNode *&newNode, int numberPassesLeft,
+    CbcNode *oldNode, OsiCuts &cuts,
+    bool &resolved, CoinWarmStartBasis *lastws,
+    const double *lowerBefore, const double *upperBefore,
+    OsiSolverBranch *&branches);
+  int chooseBranch(CbcNode *newNode, int numberPassesLeft, bool &resolved);
+
+  /** Return an empty basis object of the specified size
 
       A useful utility when constructing a basis for a subproblem from scratch.
@@ -2209 +2439 @@
       the solver attached to the model.
     */
-    CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
-
-    /** Remove inactive cuts from the model
+  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const;
+
+  /** Remove inactive cuts from the model
 
       An OsiSolverInterface is expected to maintain a valid basis, but not a
@@ -2222 +2452 @@
       on exit current cuts will be correct.  Returns number dropped
     */
-    int takeOffCuts(OsiCuts &cuts,
-                    bool allowResolve, OsiCuts * saveCuts,
-                    int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;
-
-    /** Determine and install the active cuts that need to be added for
+  int takeOffCuts(OsiCuts &cuts,
+    bool allowResolve, OsiCuts *saveCuts,
+    int numberNewCuts = 0, const OsiRowCut **newCuts = NULL);
+
+  /** Determine and install the active cuts that need to be added for
       the current subproblem
 
@@ -2238 +2468 @@
 
     */
-    int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws);
-
-    /** Traverse the tree from node to root and prep the model
+  int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws);
+
+  /** Traverse the tree from node to root and prep the model
 
       addCuts1() begins the job of prepping the model to match the current
@@ -2256 +2486 @@
         bounds and building a basis goes to waste.
     */
-    bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
-    /** Returns bounds just before where - initially original bounds.
+  bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws);
+  /** Returns bounds just before where - initially original bounds.
         Also sets downstream nodes (lower if force 1, upper if 2)
     */
-    void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
-                         double & lower, double & upper, int force);
-    /** Set objective value in a node.  This is separated out so that
+  void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn,
+    double &lower, double &upper, int force);
+  /** Set objective value in a node.  This is separated out so that
        odd solvers can use.  It may look at extra information in
        solverCharacteriscs_ and will also use bound from parent node
     */
-    void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
-
-    /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
+  void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const;
+
+  /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
         Scan and convert CbcSimpleInteger objects
     */
-    void convertToDynamic();
-    /// Set numberBeforeTrust in all objects
-    void synchronizeNumberBeforeTrust(int type = 0);
-    /// Zap integer information in problem (may leave object info)
-    void zapIntegerInformation(bool leaveObjects = true);
-    /// Use cliques for pseudocost information - return nonzero if infeasible
-    int cliquePseudoCosts(int doStatistics);
-    /// Fill in useful estimates
-    void pseudoShadow(int type);
-    /** Return pseudo costs
+  void convertToDynamic();
+  /// Set numberBeforeTrust in all objects
+  void synchronizeNumberBeforeTrust(int type = 0);
+  /// Zap integer information in problem (may leave object info)
+  void zapIntegerInformation(bool leaveObjects = true);
+  /// Use cliques for pseudocost information - return nonzero if infeasible
+  int cliquePseudoCosts(int doStatistics);
+  /// Fill in useful estimates
+  void pseudoShadow(int type);
+  /** Return pseudo costs
         If not all integers or not pseudo costs - returns all zero
         Length of arrays are numberIntegers() and entries
@@ -2286 +2516 @@
         User must allocate arrays before call
     */
-    void fillPseudoCosts(double * downCosts, double * upCosts,
-                         int * priority = NULL,
-                         int * numberDown = NULL, int * numberUp = NULL,
-                         int * numberDownInfeasible = NULL,
-                         int * numberUpInfeasible = NULL) const;
-    /** Do heuristics at root.
+  void fillPseudoCosts(double *downCosts, double *upCosts,
+    int *priority = NULL,
+    int *numberDown = NULL, int *numberUp = NULL,
+    int *numberDownInfeasible = NULL,
+    int *numberUpInfeasible = NULL) const;
+  /** Do heuristics at root.
         0 - don't delete
         1 - delete
         2 - just delete - don't even use
     */
-    void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
-    /// Adjust heuristics based on model
-    void adjustHeuristics();
-    /// Get the hotstart solution
-    inline const double * hotstartSolution() const {
-        return hotstartSolution_;
-    }
-    /// Get the hotstart priorities
-    inline const int * hotstartPriorities() const {
-        return hotstartPriorities_;
-    }
-
-    /// Return the list of cuts initially collected for this subproblem
-    inline CbcCountRowCut ** addedCuts() const {
-        return addedCuts_;
-    }
-    /// Number of entries in the list returned by #addedCuts()
-    inline int currentNumberCuts() const {
-        return currentNumberCuts_;
-    }
-    /// Global cuts
-    inline CbcRowCuts * globalCuts() {
-        return &globalCuts_;
-    }
-    /// Get rid of global cuts
-    inline void zapGlobalCuts() {
-        globalCuts_ = CbcRowCuts();
-    }
-    /// Copy and set a pointer to a row cut which will be added instead of normal branching.
-    void setNextRowCut(const OsiRowCut & cut);
-    /// Get a pointer to current node (be careful)
-    inline CbcNode * currentNode() const {
-        return currentNode_;
-    }
-    /// Get a pointer to probing info
-    inline CglTreeProbingInfo * probingInfo() const {
-        return probingInfo_;
-    }
-    /// Thread specific random number generator
-    inline CoinThreadRandom * randomNumberGenerator() {
-        return &randomNumberGenerator_;
-    }
-    /// Set the number of iterations done in strong branching.
-    inline void setNumberStrongIterations(int number) {
-        numberStrongIterations_ = number;
-    }
-    /// Get the number of iterations done in strong branching.
-    inline int numberStrongIterations() const {
-        return numberStrongIterations_;
-    }
-    /// Get maximum number of iterations (designed to be used in heuristics)
-    inline int maximumNumberIterations() const {
-        return maximumNumberIterations_;
-    }
-    /// Set maximum number of iterations (designed to be used in heuristics)
-    inline void setMaximumNumberIterations(int value) {
-        maximumNumberIterations_ = value;
-    }
+  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
+  /// Adjust heuristics based on model
+  void adjustHeuristics();
+  /// Get the hotstart solution
+  inline const double *hotstartSolution() const
+  {
+    return hotstartSolution_;
+  }
+  /// Get the hotstart priorities
+  inline const int *hotstartPriorities() const
+  {
+    return hotstartPriorities_;
+  }
+
+  /// Return the list of cuts initially collected for this subproblem
+  inline CbcCountRowCut **addedCuts() const
+  {
+    return addedCuts_;
+  }
+  /// Number of entries in the list returned by #addedCuts()
+  inline int currentNumberCuts() const
+  {
+    return currentNumberCuts_;
+  }
+  /// Global cuts
+  inline CbcRowCuts *globalCuts()
+  {
+    return &globalCuts_;
+  }
+  /// Get rid of global cuts
+  inline void zapGlobalCuts()
+  {
+    globalCuts_ = CbcRowCuts();
+  }
+  /// Copy and set a pointer to a row cut which will be added instead of normal branching.
+  void setNextRowCut(const OsiRowCut &cut);
+  /// Get a pointer to current node (be careful)
+  inline CbcNode *currentNode() const
+  {
+    return currentNode_;
+  }
+  /// Get a pointer to probing info
+  inline CglTreeProbingInfo *probingInfo() const
+  {
+    return probingInfo_;
+  }
+  /// Thread specific random number generator
+  inline CoinThreadRandom *randomNumberGenerator()
+  {
+    return &randomNumberGenerator_;
+  }
+  /// Set the number of iterations done in strong branching.
+  inline void setNumberStrongIterations(int number)
+  {
+    numberStrongIterations_ = number;
+  }
+  /// Get the number of iterations done in strong branching.
+  inline int numberStrongIterations() const
+  {
+    return numberStrongIterations_;
+  }
+  /// Get maximum number of iterations (designed to be used in heuristics)
+  inline int maximumNumberIterations() const
+  {
+    return maximumNumberIterations_;
+  }
+  /// Set maximum number of iterations (designed to be used in heuristics)
+  inline void setMaximumNumberIterations(int value)
+  {
+    maximumNumberIterations_ = value;
+  }
 #ifdef COIN_HAS_NTY
-    /// Symmetry information
-    inline CbcSymmetry * symmetryInfo() const
-    { return symmetryInfo_;}  
-    /// get rid of all
-    void zapSymmetry();
+  /// Symmetry information
+  inline CbcSymmetry *symmetryInfo() const
+  {
+    return symmetryInfo_;
+  }
+  /// get rid of all
+  void zapSymmetry();
 #endif
-    /// Set depth for fast nodes
-    inline void setFastNodeDepth(int value) {
-        fastNodeDepth_ = value;
-    }
-    /// Get depth for fast nodes
-    inline int fastNodeDepth() const {
-        return fastNodeDepth_;
-    }
-    /// Get anything with priority >= this can be treated as continuous
-    inline int continuousPriority() const {
-        return continuousPriority_;
-    }
-    /// Set anything with priority >= this can be treated as continuous
-    inline void setContinuousPriority(int value) {
-        continuousPriority_ = value;
-    }
-    inline void incrementExtra(int nodes, int iterations, int fathoms=1) {
-        numberExtraNodes_ += nodes;
-        numberExtraIterations_ += iterations;
-        numberFathoms_ += fathoms;
-    }
-    /// Zero extra
-    inline void zeroExtra() {
-        numberExtraNodes_ = 0;
-        numberExtraIterations_ = 0;
-        numberFathoms_ = 0;
-    }
-    /// Number of extra iterations
-    inline int numberExtraIterations() const {
-        return numberExtraIterations_;
-    }
-    /// Increment strong info
-    void incrementStrongInfo(int numberTimes, int numberIterations,
-                             int numberFixed, bool ifInfeasible);
-    /// Return strong info
-    inline const int * strongInfo() const {
-        return strongInfo_;
-    }
-
-    /// Return mutable strong info
-    inline int * mutableStrongInfo() {
-        return strongInfo_;
-    }
-    /// Get stored row cuts for donor/recipient CbcModel
-    CglStored * storedRowCuts() const {
-        return storedRowCuts_;
-    }
-    /// Set stored row cuts for donor/recipient CbcModel
-    void setStoredRowCuts(CglStored * cuts) {
-        storedRowCuts_ = cuts;
-    }
-    /// Says whether all dynamic integers
-    inline bool allDynamic () const {
-        return ((ownership_&0x40000000) != 0) ;
-    }
-    /// Create C++ lines to get to current state
-    void generateCpp( FILE * fp, int options);
-    /// Generate an OsiBranchingInformation object
-    OsiBranchingInformation usefulInformation() const;
-    /** Warm start object produced by heuristic or strong branching
+  /// Set depth for fast nodes
+  inline void setFastNodeDepth(int value)
+  {
+    fastNodeDepth_ = value;
+  }
+  /// Get depth for fast nodes
+  inline int fastNodeDepth() const
+  {
+    return fastNodeDepth_;
+  }
+  /// Get anything with priority >= this can be treated as continuous
+  inline int continuousPriority() const
+  {
+    return continuousPriority_;
+  }
+  /// Set anything with priority >= this can be treated as continuous
+  inline void setContinuousPriority(int value)
+  {
+    continuousPriority_ = value;
+  }
+  inline void incrementExtra(int nodes, int iterations, int fathoms = 1)
+  {
+    numberExtraNodes_ += nodes;
+    numberExtraIterations_ += iterations;
+    numberFathoms_ += fathoms;
+  }
+  /// Zero extra
+  inline void zeroExtra()
+  {
+    numberExtraNodes_ = 0;
+    numberExtraIterations_ = 0;
+    numberFathoms_ = 0;
+  }
+  /// Number of extra iterations
+  inline int numberExtraIterations() const
+  {
+    return numberExtraIterations_;
+  }
+  /// Increment strong info
+  void incrementStrongInfo(int numberTimes, int numberIterations,
+    int numberFixed, bool ifInfeasible);
+  /// Return strong info
+  inline const int *strongInfo() const
+  {
+    return strongInfo_;
+  }
+
+  /// Return mutable strong info
+  inline int *mutableStrongInfo()
+  {
+    return strongInfo_;
+  }
+  /// Get stored row cuts for donor/recipient CbcModel
+  CglStored *storedRowCuts() const
+  {
+    return storedRowCuts_;
+  }
+  /// Set stored row cuts for donor/recipient CbcModel
+  void setStoredRowCuts(CglStored *cuts)
+  {
+    storedRowCuts_ = cuts;
+  }
+  /// Says whether all dynamic integers
+  inline bool allDynamic() const
+  {
+    return ((ownership_ & 0x40000000) != 0);
+  }
+  /// Create C++ lines to get to current state
+  void generateCpp(FILE *fp, int options);
+  /// Generate an OsiBranchingInformation object
+  OsiBranchingInformation usefulInformation() const;
+  /** Warm start object produced by heuristic or strong branching
 
         If get a valid integer solution outside branch and bound then it can take
@@ -2426 +2683 @@
         any size then it will be used in solve.
     */
-    inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) {
-        bestSolutionBasis_ = bestSolutionBasis;
-    }
-    /// Redo walkback arrays
-    void redoWalkBack();
-    //@}
-    
-    void setMIPStart( const std::vector< std::pair< std::string, double > > &mips ) {
-       this->mipStart_ = mips;
-    }
-
-    /** may be safer to use this overload method: c++ string libraries 
+  inline void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
+  {
+    bestSolutionBasis_ = bestSolutionBasis;
+  }
+  /// Redo walkback arrays
+  void redoWalkBack();
+  //@}
+
+  void setMIPStart(const std::vector<std::pair<std::string, double>> &mips)
+  {
+    this->mipStart_ = mips;
+  }
+
+  /** may be safer to use this overload method: c++ string libraries 
      * implementation may not be binary compatible */
-    void setMIPStart( int count, const char **colNames, const double colValues[] );
-
-    const std::vector< std::pair< std::string, double > > &getMIPStart() {
-       return this->mipStart_;
-    }
-
-
-//---------------------------------------------------------------------------
+  void setMIPStart(int count, const char **colNames, const double colValues[]);
+
+  const std::vector<std::pair<std::string, double>> &getMIPStart()
+  {
+    return this->mipStart_;
+  }
+
+  //---------------------------------------------------------------------------
 
 private:
-    ///@name Private member data
-    //@{
-
-    /// The solver associated with this model.
-    OsiSolverInterface * solver_;
-
-    /** Ownership of objects and other stuff
+  ///@name Private member data
+  //@{
+
+  /// The solver associated with this model.
+  OsiSolverInterface *solver_;
+
+  /** Ownership of objects and other stuff
 
         0x80000000 model owns solver
         0x40000000 all variables CbcDynamicPseudoCost
     */
-    unsigned int ownership_ ;
-
-    /// A copy of the solver, taken at the continuous (root) node.
-    OsiSolverInterface * continuousSolver_;
-
-    /// A copy of the solver, taken at constructor or by saveReferenceSolver
-    OsiSolverInterface * referenceSolver_;
-
-    /// Message handler
-    CoinMessageHandler * handler_;
-
-    /** Flag to say if handler_ is the default handler.
+  unsigned int ownership_;
+
+  /// A copy of the solver, taken at the continuous (root) node.
+  OsiSolverInterface *continuousSolver_;
+
+  /// A copy of the solver, taken at constructor or by saveReferenceSolver
+  OsiSolverInterface *referenceSolver_;
+
+  /// Message handler
+  CoinMessageHandler *handler_;
+
+  /** Flag to say if handler_ is the default handler.
 
       The default handler is deleted when the model is deleted. Other
       handlers (supplied by the client) will not be deleted.
     */
-    bool defaultHandler_;
-
-    /// Cbc messages
-    CoinMessages messages_;
-
-    /// Array for integer parameters
-    int intParam_[CbcLastIntParam];
-
-    /// Array for double parameters
-    double dblParam_[CbcLastDblParam];
-
-    /** Pointer to an empty warm start object
+  bool defaultHandler_;
+
+  /// Cbc messages
+  CoinMessages messages_;
+
+  /// Array for integer parameters
+  int intParam_[CbcLastIntParam];
+
+  /// Array for double parameters
+  double dblParam_[CbcLastDblParam];
+
+  /** Pointer to an empty warm start object
 
       It turns out to be useful to have this available as a base from
@@ -2495 +2754 @@
       start. See getEmptyBasis for an example of how this field can be used.
     */
-    mutable CoinWarmStart *emptyWarmStart_ ;
-
-    /// Best objective
-    double bestObjective_;
-    /// Best possible objective
-    double bestPossibleObjective_;
-    /// Sum of Changes to objective by first solve
-    double sumChangeObjective1_;
-    /// Sum of Changes to objective by subsequent solves
-    double sumChangeObjective2_;
-
-    /// Array holding the incumbent (best) solution.
-    double * bestSolution_;
-    /// Arrays holding other solutions.
-    double ** savedSolutions_;
-
-    /** Array holding the current solution.
+  mutable CoinWarmStart *emptyWarmStart_;
+
+  /// Best objective
+  double bestObjective_;
+  /// Best possible objective
+  double bestPossibleObjective_;
+  /// Sum of Changes to objective by first solve
+  double sumChangeObjective1_;
+  /// Sum of Changes to objective by subsequent solves
+  double sumChangeObjective2_;
+
+  /// Array holding the incumbent (best) solution.
+  double *bestSolution_;
+  /// Arrays holding other solutions.
+  double **savedSolutions_;
+
+  /** Array holding the current solution.
 
       This array is used more as a temporary.
     */
-    double * currentSolution_;
-    /** For testing infeasibilities - will point to
+  double *currentSolution_;
+  /** For testing infeasibilities - will point to
         currentSolution_ or solver-->getColSolution()
     */
-    mutable const double * testSolution_;
-    /** MIPstart values
+  mutable const double *testSolution_;
+  /** MIPstart values
       values for integer variables which will be converted to a complete integer initial feasible solution
     */
-    std::vector< std::pair< std::string, double > > mipStart_;
-     /** Warm start object produced by heuristic or strong branching
+  std::vector<std::pair<std::string, double>> mipStart_;
+  /** Warm start object produced by heuristic or strong branching
 
         If get a valid integer solution outside branch and bound then it can take
@@ -2530 +2789 @@
         any size then it will be used in solve.
     */
-    CoinWarmStartBasis bestSolutionBasis_ ;
-    /// Global cuts
-    CbcRowCuts globalCuts_;
-    /// Global conflict cuts
-    CbcRowCuts * globalConflictCuts_;
-
-    /// Minimum degradation in objective value to continue cut generation
-    double minimumDrop_;
-    /// Number of solutions
-    int numberSolutions_;
-    /// Number of saved solutions
-    int numberSavedSolutions_;
-    /// Maximum number of saved solutions
-    int maximumSavedSolutions_;
-    /** State of search
+  CoinWarmStartBasis bestSolutionBasis_;
+  /// Global cuts
+  CbcRowCuts globalCuts_;
+  /// Global conflict cuts
+  CbcRowCuts *globalConflictCuts_;
+
+  /// Minimum degradation in objective value to continue cut generation
+  double minimumDrop_;
+  /// Number of solutions
+  int numberSolutions_;
+  /// Number of saved solutions
+  int numberSavedSolutions_;
+  /// Maximum number of saved solutions
+  int maximumSavedSolutions_;
+  /** State of search
         0 - no solution
         1 - only heuristic solutions
@@ -2550 +2809 @@
         3 - no solution but many nodes
     */
-    int stateOfSearch_;
-    /// At which depths to do cuts
-    int whenCuts_;
-    /// Hotstart solution
-    double * hotstartSolution_;
-    /// Hotstart priorities
-    int * hotstartPriorities_;
-    /// Number of heuristic solutions
-    int numberHeuristicSolutions_;
-    /// Cumulative number of nodes
-    int numberNodes_;
-    /** Cumulative number of nodes for statistics.
+  int stateOfSearch_;
+  /// At which depths to do cuts
+  int whenCuts_;
+  /// Hotstart solution
+  double *hotstartSolution_;
+  /// Hotstart priorities
+  int *hotstartPriorities_;
+  /// Number of heuristic solutions
+  int numberHeuristicSolutions_;
+  /// Cumulative number of nodes
+  int numberNodes_;
+  /** Cumulative number of nodes for statistics.
         Must fix to match up
     */
-    int numberNodes2_;
-    /// Cumulative number of iterations
-    int numberIterations_;
-    /// Cumulative number of solves
-    int numberSolves_;
-    /// Status of problem - 0 finished, 1 stopped, 2 difficulties
-    int status_;
-    /** Secondary status of problem
+  int numberNodes2_;
+  /// Cumulative number of iterations
+  int numberIterations_;
+  /// Cumulative number of solves
+  int numberSolves_;
+  /// Status of problem - 0 finished, 1 stopped, 2 difficulties
+  int status_;
+  /** Secondary status of problem
         -1 unset (status_ will also be -1)
         0 search completed with solution
@@ -2581 +2840 @@
         6 stopped on solutions
      */
-    int secondaryStatus_;
-    /// Number of integers in problem
-    int numberIntegers_;
-    /// Number of rows at continuous
-    int numberRowsAtContinuous_;
-    /**
+  int secondaryStatus_;
+  /// Number of integers in problem
+  int numberIntegers_;
+  /// Number of rows at continuous
+  int numberRowsAtContinuous_;
+  /**
        -1 - cutoff as constraint not activated
        -2 - waiting to activate
        >=0 - activated
      */
-    int cutoffRowNumber_;
-    /// Maximum number of cuts
-    int maximumNumberCuts_;
-    /** Current phase (so heuristics etc etc can find out).
+  int cutoffRowNumber_;
+  /// Maximum number of cuts
+  int maximumNumberCuts_;
+  /** Current phase (so heuristics etc etc can find out).
         0 - initial solve
         1 - solve with cuts at root
@@ -2602 +2861 @@
         5 - at end of search
     */
-    int phase_;
-
-    /// Number of entries in #addedCuts_
-    int currentNumberCuts_;
-
-    /** Current limit on search tree depth
+  int phase_;
+
+  /// Number of entries in #addedCuts_
+  int currentNumberCuts_;
+
+  /** Current limit on search tree depth
 
       The allocated size of #walkback_. Increased as needed.
     */
-    int maximumDepth_;
-    /** Array used to assemble the path between a node and the search tree root
+  int maximumDepth_;
+  /** Array used to assemble the path between a node and the search tree root
 
       The array is resized when necessary. #maximumDepth_  is the current
       allocated size.
     */
-    CbcNodeInfo ** walkback_;
-    /// preProcess used before branch and bound (optional)
-    CglPreProcess * preProcess_;
-    CbcNodeInfo ** lastNodeInfo_;
-    const OsiRowCut ** lastCut_;
-    int lastDepth_;
-    int lastNumberCuts2_;
-    int maximumCuts_;
-    int * lastNumberCuts_;
-
-    /** The list of cuts initially collected for this subproblem
+  CbcNodeInfo **walkback_;
+  /// preProcess used before branch and bound (optional)
+  CglPreProcess *preProcess_;
+  CbcNodeInfo **lastNodeInfo_;
+  const OsiRowCut **lastCut_;
+  int lastDepth_;
+  int lastNumberCuts2_;
+  int maximumCuts_;
+  int *lastNumberCuts_;
+
+  /** The list of cuts initially collected for this subproblem
 
       When the subproblem at this node is rebuilt, a set of cuts is collected
@@ -2634 +2893 @@
       entry is set to NULL.
     */
-    CbcCountRowCut ** addedCuts_;
-
-    /** A pointer to a row cut which will be added instead of normal branching.
+  CbcCountRowCut **addedCuts_;
+
+  /** A pointer to a row cut which will be added instead of normal branching.
         After use it should be set to NULL.
     */
-    OsiRowCut * nextRowCut_;
-
-    /// Current node so can be used elsewhere
-    CbcNode * currentNode_;
-
-    /// Indices of integer variables
-    int * integerVariable_;
-    /// Whether of not integer
-    char * integerInfo_;
-    /// Holds solution at continuous (after cuts)
-    double * continuousSolution_;
-    /// Array marked whenever a solution is found if non-zero
-    int * usedInSolution_;
-    /**
+  OsiRowCut *nextRowCut_;
+
+  /// Current node so can be used elsewhere
+  CbcNode *currentNode_;
+
+  /// Indices of integer variables
+  int *integerVariable_;
+  /// Whether of not integer
+  char *integerInfo_;
+  /// Holds solution at continuous (after cuts)
+  double *continuousSolution_;
+  /// Array marked whenever a solution is found if non-zero
+  int *usedInSolution_;
+  /**
         Special options
         0 bit (1) - check if cuts valid (if on debugger list)
@@ -2679 +2938 @@
         24 bit (16777216) - just get feasible if no cutoff
     */
-    int specialOptions_;
-    /** More special options
+  int specialOptions_;
+  /** More special options
         at present bottom 6 bits used for shadow price mode
         1024 for experimental hotstart
@@ -2694 +2953 @@
         21 bit (2097152) - Reduce sum of infeasibilities after cuts
     */
-    int moreSpecialOptions_;
-    /** More more special options
+  int moreSpecialOptions_;
+  /** More more special options
         0 bit (1) - find switching variables
         1 bit (2) - using fake objective until solution
@@ -2708 +2967 @@
         11/12 bit 2048 - intermittent cuts
     */
-    int moreSpecialOptions2_;
-    /// User node comparison function
-    CbcCompareBase * nodeCompare_;
-    /// User feasibility function (see CbcFeasibleBase.hpp)
-    CbcFeasibilityBase * problemFeasibility_;
-    /// Tree
-    CbcTree * tree_;
-    /// Pointer to top of tree
-    CbcFullNodeInfo * topOfTree_;
-    /// A pointer to model to be used for subtrees
-    CbcModel * subTreeModel_;
-    /// A pointer to model from CbcHeuristic
-    CbcModel * heuristicModel_;
-    /// Number of times any subtree stopped on nodes, time etc
-    int numberStoppedSubTrees_;
-    /// Variable selection function
-    CbcBranchDecision * branchingMethod_;
-    /// Cut modifier function
-    CbcCutModifier * cutModifier_;
-    /// Strategy
-    CbcStrategy * strategy_;
-    /// Parent model
-    CbcModel * parentModel_;
-    /** Whether to automatically do presolve before branch and bound.
+  int moreSpecialOptions2_;
+  /// User node comparison function
+  CbcCompareBase *nodeCompare_;
+  /// User feasibility function (see CbcFeasibleBase.hpp)
+  CbcFeasibilityBase *problemFeasibility_;
+  /// Tree
+  CbcTree *tree_;
+  /// Pointer to top of tree
+  CbcFullNodeInfo *topOfTree_;
+  /// A pointer to model to be used for subtrees
+  CbcModel *subTreeModel_;
+  /// A pointer to model from CbcHeuristic
+  CbcModel *heuristicModel_;
+  /// Number of times any subtree stopped on nodes, time etc
+  int numberStoppedSubTrees_;
+  /// Variable selection function
+  CbcBranchDecision *branchingMethod_;
+  /// Cut modifier function
+  CbcCutModifier *cutModifier_;
+  /// Strategy
+  CbcStrategy *strategy_;
+  /// Parent model
+  CbcModel *parentModel_;
+  /** Whether to automatically do presolve before branch and bound.
         0 - no
         1 - ordinary presolve
         2 - integer presolve (dodgy)
     */
-    /// Pointer to array[getNumCols()] (for speed) of column lower bounds
-    const double * cbcColLower_;
-    /// Pointer to array[getNumCols()] (for speed) of column upper bounds
-    const double * cbcColUpper_;
-    /// Pointer to array[getNumRows()] (for speed) of row lower bounds
-    const double * cbcRowLower_;
-    /// Pointer to array[getNumRows()] (for speed) of row upper bounds
-    const double * cbcRowUpper_;
-    /// Pointer to array[getNumCols()] (for speed) of primal solution vector
-    const double * cbcColSolution_;
-    /// Pointer to array[getNumRows()] (for speed) of dual prices
-    const double * cbcRowPrice_;
-    /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
-    const double * cbcReducedCost_;
-    /// Pointer to array[getNumRows()] (for speed) of row activity levels.
-    const double * cbcRowActivity_;
-    /// Pointer to user-defined data structure
-    void * appData_;
-    /// Presolve for CbcTreeLocal
-    int presolve_;
-    /** Maximum number of candidates to consider for strong branching.
+  /// Pointer to array[getNumCols()] (for speed) of column lower bounds
+  const double *cbcColLower_;
+  /// Pointer to array[getNumCols()] (for speed) of column upper bounds
+  const double *cbcColUpper_;
+  /// Pointer to array[getNumRows()] (for speed) of row lower bounds
+  const double *cbcRowLower_;
+  /// Pointer to array[getNumRows()] (for speed) of row upper bounds
+  const double *cbcRowUpper_;
+  /// Pointer to array[getNumCols()] (for speed) of primal solution vector
+  const double *cbcColSolution_;
+  /// Pointer to array[getNumRows()] (for speed) of dual prices
+  const double *cbcRowPrice_;
+  /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
+  const double *cbcReducedCost_;
+  /// Pointer to array[getNumRows()] (for speed) of row activity levels.
+  const double *cbcRowActivity_;
+  /// Pointer to user-defined data structure
+  void *appData_;
+  /// Presolve for CbcTreeLocal
+  int presolve_;
+  /** Maximum number of candidates to consider for strong branching.
       To disable strong branching, set this to 0.
     */
-    int numberStrong_;
-    /** \brief The number of branches before pseudo costs believed
+  int numberStrong_;
+  /** \brief The number of branches before pseudo costs believed
            in dynamic strong branching.
 
       A value of 0 is  off.
     */
-    int numberBeforeTrust_;
-    /** \brief The number of variables for which to compute penalties
+  int numberBeforeTrust_;
+  /** \brief The number of variables for which to compute penalties
            in dynamic strong branching.
     */
-    int numberPenalties_;
-    /// For threads - stop after this many "iterations"
-    int stopNumberIterations_;
-    /** Scale factor to make penalties match strong.
+  int numberPenalties_;
+  /// For threads - stop after this many "iterations"
+  int stopNumberIterations_;
+  /** Scale factor to make penalties match strong.
         Should/will be computed */
-    double penaltyScaleFactor_;
-    /// Number of analyze iterations to do
-    int numberAnalyzeIterations_;
-    /// Arrays with analysis results
-    double * analyzeResults_;
-    /// Useful temporary pointer
-    void * temporaryPointer_;
-    /// Number of nodes infeasible by normal branching (before cuts)
-    int numberInfeasibleNodes_;
-    /** Problem type as set by user or found by analysis.  This will be extended
+  double penaltyScaleFactor_;
+  /// Number of analyze iterations to do
+  int numberAnalyzeIterations_;
+  /// Arrays with analysis results
+  double *analyzeResults_;
+  /// Useful temporary pointer
+  void *temporaryPointer_;
+  /// Number of nodes infeasible by normal branching (before cuts)
+  int numberInfeasibleNodes_;
+  /** Problem type as set by user or found by analysis.  This will be extended
         0 - not known
         1 - Set partitioning <=
@@ -2789 +3048 @@
         3 - Set covering
     */
-    int problemType_;
-    /// Print frequency
-    int printFrequency_;
-    /// Number of cut generators
-    int numberCutGenerators_;
-    // Cut generators
-    CbcCutGenerator ** generator_;
-    // Cut generators before any changes
-    CbcCutGenerator ** virginGenerator_;
-    /// Number of heuristics
-    int numberHeuristics_;
-    /// Heuristic solvers
-    CbcHeuristic ** heuristic_;
-    /// Pointer to heuristic solver which found last solution (or NULL)
-    CbcHeuristic * lastHeuristic_;
-    /// Depth for fast nodes
-    int fastNodeDepth_;
-    /*! Pointer to the event handler */
-# ifdef CBC_ONLY_CLP
-    ClpEventHandler *eventHandler_ ;
-# else
-    CbcEventHandler *eventHandler_ ;
-# endif
-   /// Symmetry information
-    CbcSymmetry * symmetryInfo_;
-    /// Total number of objects
-    int numberObjects_;
-
-    /** \brief Integer and Clique and ... information
+  int problemType_;
+  /// Print frequency
+  int printFrequency_;
+  /// Number of cut generators
+  int numberCutGenerators_;
+  // Cut generators
+  CbcCutGenerator **generator_;
+  // Cut generators before any changes
+  CbcCutGenerator **virginGenerator_;
+  /// Number of heuristics
+  int numberHeuristics_;
+  /// Heuristic solvers
+  CbcHeuristic **heuristic_;
+  /// Pointer to heuristic solver which found last solution (or NULL)
+  CbcHeuristic *lastHeuristic_;
+  /// Depth for fast nodes
+  int fastNodeDepth_;
+  /*! Pointer to the event handler */
+#ifdef CBC_ONLY_CLP
+  ClpEventHandler *eventHandler_;
+#else
+  CbcEventHandler *eventHandler_;
+#endif
+  /// Symmetry information
+  CbcSymmetry *symmetryInfo_;
+  /// Total number of objects
+  int numberObjects_;
+
+  /** \brief Integer and Clique and ... information
 
       \note The code assumes that the first objects on the list will be
@@ -2827 +3086 @@
         objects.
     */
-    OsiObject ** object_;
-    /// Now we may not own objects - just point to solver's objects
-    bool ownObjects_;
-
-    /// Original columns as created by integerPresolve or preprocessing
-    int * originalColumns_;
-    /// How often to scan global cuts
-    int howOftenGlobalScan_;
-    /** Number of times global cuts violated.  When global cut pool then this
+  OsiObject **object_;
+  /// Now we may not own objects - just point to solver's objects
+  bool ownObjects_;
+
+  /// Original columns as created by integerPresolve or preprocessing
+  int *originalColumns_;
+  /// How often to scan global cuts
+  int howOftenGlobalScan_;
+  /** Number of times global cuts violated.  When global cut pool then this
         should be kept for each cut and type of cut */
-    int numberGlobalViolations_;
-    /// Number of extra iterations in fast lp
-    int numberExtraIterations_;
-    /// Number of extra nodes in fast lp
-    int numberExtraNodes_;
-    /// Number of times fast lp entered
-    int numberFathoms_;
-    /** Value of objective at continuous
+  int numberGlobalViolations_;
+  /// Number of extra iterations in fast lp
+  int numberExtraIterations_;
+  /// Number of extra nodes in fast lp
+  int numberExtraNodes_;
+  /// Number of times fast lp entered
+  int numberFathoms_;
+  /** Value of objective at continuous
         (Well actually after initial round of cuts)
     */
-    double continuousObjective_;
-    /** Value of objective before root node cuts added
-    */
-    double originalContinuousObjective_;
-    /// Number of infeasibilities at continuous
-    int continuousInfeasibilities_;
-    /// Maximum number of cut passes at root
-    int maximumCutPassesAtRoot_;
-    /// Maximum number of cut passes
-    int maximumCutPasses_;
-    /// Preferred way of branching
-    int preferredWay_;
-    /// Current cut pass number
-    int currentPassNumber_;
-    /// Maximum number of cuts (for whichGenerator_)
-    int maximumWhich_;
-    /// Maximum number of rows
-    int maximumRows_;
-    /// Random seed
-    int randomSeed_;
-    /// Multiple root tries
-    int multipleRootTries_;
-    /// Current depth
-    int currentDepth_;
-    /// Thread specific random number generator
-    mutable CoinThreadRandom randomNumberGenerator_;
-    /// Work basis for temporary use
-    CoinWarmStartBasis workingBasis_;
-    /// Which cut generator generated this cut
-    int * whichGenerator_;
-    /// Maximum number of statistics
-    int maximumStatistics_;
-    /// statistics
-    CbcStatistics ** statistics_;
-    /// Maximum depth reached
-    int maximumDepthActual_;
-    /// Number of reduced cost fixings
-    double numberDJFixed_;
-    /// Probing info
-    CglTreeProbingInfo * probingInfo_;
-    /// Number of fixed by analyze at root
-    int numberFixedAtRoot_;
-    /// Number fixed by analyze so far
-    int numberFixedNow_;
-    /// Whether stopping on gap
-    bool stoppedOnGap_;
-    /// Whether event happened
-    mutable bool eventHappened_;
-    /// Number of long strong goes
-    int numberLongStrong_;
-    /// Number of old active cuts
-    int numberOldActiveCuts_;
-    /// Number of new cuts
-    int numberNewCuts_;
-    /// Strategy worked out - mainly at root node
-    int searchStrategy_;
-    /** Strategy for strong branching
+  double continuousObjective_;
+  /** Value of objective before root node cuts added
+    */
+  double originalContinuousObjective_;
+  /// Number of infeasibilities at continuous
+  int continuousInfeasibilities_;
+  /// Maximum number of cut passes at root
+  int maximumCutPassesAtRoot_;
+  /// Maximum number of cut passes
+  int maximumCutPasses_;
+  /// Preferred way of branching
+  int preferredWay_;
+  /// Current cut pass number
+  int currentPassNumber_;
+  /// Maximum number of cuts (for whichGenerator_)
+  int maximumWhich_;
+  /// Maximum number of rows
+  int maximumRows_;
+  /// Random seed
+  int randomSeed_;
+  /// Multiple root tries
+  int multipleRootTries_;
+  /// Current depth
+  int currentDepth_;
+  /// Thread specific random number generator
+  mutable CoinThreadRandom randomNumberGenerator_;
+  /// Work basis for temporary use
+  CoinWarmStartBasis workingBasis_;
+  /// Which cut generator generated this cut
+  int *whichGenerator_;
+  /// Maximum number of statistics
+  int maximumStatistics_;
+  /// statistics
+  CbcStatistics **statistics_;
+  /// Maximum depth reached
+  int maximumDepthActual_;
+  /// Number of reduced cost fixings
+  double numberDJFixed_;
+  /// Probing info
+  CglTreeProbingInfo *probingInfo_;
+  /// Number of fixed by analyze at root
+  int numberFixedAtRoot_;
+  /// Number fixed by analyze so far
+  int numberFixedNow_;
+  /// Whether stopping on gap
+  bool stoppedOnGap_;
+  /// Whether event happened
+  mutable bool eventHappened_;
+  /// Number of long strong goes
+  int numberLongStrong_;
+  /// Number of old active cuts
+  int numberOldActiveCuts_;
+  /// Number of new cuts
+  int numberNewCuts_;
+  /// Strategy worked out - mainly at root node
+  int searchStrategy_;
+  /** Strategy for strong branching
         0 - normal
         when to do all fractional
@@ -2914 +3173 @@
         If >=100 then do when depth <= strategy/100 (otherwise 5)
      */
-    int strongStrategy_;
-    /// Number of iterations in strong branching
-    int numberStrongIterations_;
-    /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible
+  int strongStrategy_;
+  /// Number of iterations in strong branching
+  int numberStrongIterations_;
+  /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible
         Second group of three is a snapshot at node [6] */
-    int strongInfo_[7];
-    /**
+  int strongInfo_[7];
+  /**
         For advanced applications you may wish to modify the behavior of Cbc
         e.g. if the solver is a NLP solver then you may not have an exact
@@ -2926 +3185 @@
         For actually saving/restoring a solution you need the actual solver one.
     */
-    OsiBabSolver * solverCharacteristics_;
-    /// Whether to force a resolve after takeOffCuts
-    bool resolveAfterTakeOffCuts_;
-    /// Maximum number of iterations (designed to be used in heuristics)
-    int maximumNumberIterations_;
-    /// Anything with priority >= this can be treated as continuous
-    int continuousPriority_;
-    /// Number of outstanding update information items
-    int numberUpdateItems_;
-    /// Maximum number of outstanding update information items
-    int maximumNumberUpdateItems_;
-    /// Update items
-    CbcObjectUpdateData * updateItems_;
-    /// Stored row cuts for donor/recipient CbcModel
-    CglStored * storedRowCuts_;
-    /**
+  OsiBabSolver *solverCharacteristics_;
+  /// Whether to force a resolve after takeOffCuts
+  bool resolveAfterTakeOffCuts_;
+  /// Maximum number of iterations (designed to be used in heuristics)
+  int maximumNumberIterations_;
+  /// Anything with priority >= this can be treated as continuous
+  int continuousPriority_;
+  /// Number of outstanding update information items
+  int numberUpdateItems_;
+  /// Maximum number of outstanding update information items
+  int maximumNumberUpdateItems_;
+  /// Update items
+  CbcObjectUpdateData *updateItems_;
+  /// Stored row cuts for donor/recipient CbcModel
+  CglStored *storedRowCuts_;
+  /**
        Parallel
        0 - off
@@ -2948 +3207 @@
        other special meanings
     */
-    int numberThreads_;
-    /** thread mode
+  int numberThreads_;
+  /** thread mode
         always use numberThreads for branching
         1 set then deterministic
@@ -2956 +3215 @@
         default is 0
     */
-    int threadMode_;
-    /// Number of global cuts on entry to a node
-    int numberGlobalCutsIn_;
-    /// Thread stuff for master
-    CbcBaseModel * master_;
-    /// Pointer to masterthread
-    CbcThread * masterThread_;
-//@}
+  int threadMode_;
+  /// Number of global cuts on entry to a node
+  int numberGlobalCutsIn_;
+  /// Thread stuff for master
+  CbcBaseModel *master_;
+  /// Pointer to masterthread
+  CbcThread *masterThread_;
+  //@}
 };
 /// So we can use osiObject or CbcObject during transition
-void getIntegerInformation(const OsiObject * object, double & originalLower,
-                           double & originalUpper) ;
+void getIntegerInformation(const OsiObject *object, double &originalLower,
+  double &originalUpper);
 // So we can call from other programs
 // Real main program
 class OsiClpSolverInterface;
-int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
-int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
+int CbcMain(int argc, const char *argv[], OsiClpSolverInterface &solver, CbcModel **babSolver);
+int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
 // four ways of calling
-int callCbc(const char * input2, OsiClpSolverInterface& solver1);
-int callCbc(const char * input2);
-int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
-int callCbc(const std::string input2) ;
+int callCbc(const char *input2, OsiClpSolverInterface &solver1);
+int callCbc(const char *input2);
+int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
+int callCbc(const std::string input2);
 // When we want to load up CbcModel with options first
-void CbcMain0 (CbcModel & babSolver);
-int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
+void CbcMain0(CbcModel &babSolver);
+int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
 // two ways of calling
-int callCbc(const char * input2, CbcModel & babSolver);
-int callCbc(const std::string input2, CbcModel & babSolver);
+int callCbc(const char *input2, CbcModel &babSolver);
+int callCbc(const std::string input2, CbcModel &babSolver);
 // And when CbcMain0 already called to initialize
-int callCbc1(const char * input2, CbcModel & babSolver);
-int callCbc1(const std::string input2, CbcModel & babSolver);
+int callCbc1(const char *input2, CbcModel &babSolver);
+int callCbc1(const std::string input2, CbcModel &babSolver);
 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
-int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
-int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
-int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
+int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
+int callCbc1(const std::string input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
+int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
 // For uniform setting of cut and heuristic options
-void setCutAndHeuristicOptions(CbcModel & model);
+void setCutAndHeuristicOptions(CbcModel &model);
 #endif
-