casadi 3.7.2__cp314-none-win_amd64.whl

casadi/include/coin/CbcOrClpParam.cpp

@@ -0,0 +1,4321 @@
+/* $Id$ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#include "CoinPragma.hpp"
+#include "CoinTime.hpp"
+#include "CbcOrClpParam.hpp"
+
+#include <string>
+#include <iostream>
+#include <cassert>
+
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_CLP
+#include "OsiClpSolverInterface.hpp"
+#include "ClpSimplex.hpp"
+#endif
+#include "CbcModel.hpp"
+#endif
+#include "CoinHelperFunctions.hpp"
+#ifdef COIN_HAS_CLP
+#include "ClpSimplex.hpp"
+#include "ClpFactorization.hpp"
+#endif
+#ifdef COIN_HAS_READLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+#ifdef COIN_HAS_CBC
+// from CoinSolve
+static char coin_prompt[] = "Coin:";
+#else
+static char coin_prompt[] = "Clp:";
+#endif
+#ifdef CLP_CILK
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#if defined(COIN_HAS_WSMP) && !defined(USE_EKKWSSMP)
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#include "ClpConfig.h"
+#ifdef CLP_HAS_ABC
+#include "AbcCommon.hpp"
+#endif
+static bool doPrinting = true;
+static std::string afterEquals = "";
+static char printArray[250];
+#if COIN_INT_MAX == 0
+#undef COIN_INT_MAX
+#define COIN_INT_MAX 2147483647
+#endif
+#if FLUSH_PRINT_BUFFER > 2
+int coinFlushBufferFlag = 0;
+#endif
+void setCbcOrClpPrinting(bool yesNo)
+{
+  doPrinting = yesNo;
+}
+//#############################################################################
+// Constructors / Destructor / Assignment
+//#############################################################################
+
+//-------------------------------------------------------------------
+// Default Constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam()
+  : type_(CBC_PARAM_NOTUSED_INVALID)
+  , lowerDoubleValue_(0.0)
+  , upperDoubleValue_(0.0)
+  , lowerIntValue_(0)
+  , upperIntValue_(0)
+  , lengthName_(0)
+  , lengthMatch_(0)
+  , definedKeyWords_()
+  , name_()
+  , shortHelp_()
+  , longHelp_()
+  , action_(CBC_PARAM_NOTUSED_INVALID)
+  , currentKeyWord_(-1)
+  , display_(0)
+  , intValue_(-1)
+  , doubleValue_(-1.0)
+  , stringValue_("")
+  , whereUsed_(7)
+  , fakeKeyWord_(-1)
+  , fakeValue_(0)
+{
+}
+// Other constructors
+CbcOrClpParam::CbcOrClpParam(std::string name, std::string help,
+  double lower, double upper, CbcOrClpParameterType type,
+  int display)
+  : type_(type)
+  , lowerIntValue_(0)
+  , upperIntValue_(0)
+  , definedKeyWords_()
+  , name_(name)
+  , shortHelp_(help)
+  , longHelp_()
+  , action_(type)
+  , currentKeyWord_(-1)
+  , display_(display)
+  , intValue_(-1)
+  , doubleValue_(-1.0)
+  , stringValue_("")
+  , whereUsed_(7)
+  , fakeKeyWord_(-1)
+  , fakeValue_(0)
+{
+  lowerDoubleValue_ = lower;
+  upperDoubleValue_ = upper;
+  gutsOfConstructor();
+}
+CbcOrClpParam::CbcOrClpParam(std::string name, std::string help,
+  int lower, int upper, CbcOrClpParameterType type,
+  int display)
+  : type_(type)
+  , lowerDoubleValue_(0.0)
+  , upperDoubleValue_(0.0)
+  , definedKeyWords_()
+  , name_(name)
+  , shortHelp_(help)
+  , longHelp_()
+  , action_(type)
+  , currentKeyWord_(-1)
+  , display_(display)
+  , intValue_(-1)
+  , doubleValue_(-1.0)
+  , stringValue_("")
+  , whereUsed_(7)
+  , fakeKeyWord_(-1)
+  , fakeValue_(0)
+{
+  gutsOfConstructor();
+  lowerIntValue_ = lower;
+  upperIntValue_ = upper;
+}
+// Other strings will be added by append
+CbcOrClpParam::CbcOrClpParam(std::string name, std::string help,
+  std::string firstValue,
+  CbcOrClpParameterType type, int whereUsed,
+  int display)
+  : type_(type)
+  , lowerDoubleValue_(0.0)
+  , upperDoubleValue_(0.0)
+  , lowerIntValue_(0)
+  , upperIntValue_(0)
+  , definedKeyWords_()
+  , name_(name)
+  , shortHelp_(help)
+  , longHelp_()
+  , action_(type)
+  , currentKeyWord_(0)
+  , display_(display)
+  , intValue_(-1)
+  , doubleValue_(-1.0)
+  , stringValue_("")
+  , whereUsed_(whereUsed)
+  , fakeKeyWord_(-1)
+  , fakeValue_(0)
+{
+  gutsOfConstructor();
+  definedKeyWords_.push_back(firstValue);
+}
+// Action
+CbcOrClpParam::CbcOrClpParam(std::string name, std::string help,
+  CbcOrClpParameterType type, int whereUsed,
+  int display)
+  : type_(type)
+  , lowerDoubleValue_(0.0)
+  , upperDoubleValue_(0.0)
+  , lowerIntValue_(0)
+  , upperIntValue_(0)
+  , definedKeyWords_()
+  , name_(name)
+  , shortHelp_(help)
+  , longHelp_()
+  , action_(type)
+  , currentKeyWord_(-1)
+  , display_(display)
+  , intValue_(-1)
+  , doubleValue_(-1.0)
+  , stringValue_("")
+  , fakeKeyWord_(-1)
+  , fakeValue_(0)
+{
+  whereUsed_ = whereUsed;
+  gutsOfConstructor();
+}
+
+//-------------------------------------------------------------------
+// Copy constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam(const CbcOrClpParam &rhs)
+{
+  type_ = rhs.type_;
+  lowerDoubleValue_ = rhs.lowerDoubleValue_;
+  upperDoubleValue_ = rhs.upperDoubleValue_;
+  lowerIntValue_ = rhs.lowerIntValue_;
+  upperIntValue_ = rhs.upperIntValue_;
+  lengthName_ = rhs.lengthName_;
+  lengthMatch_ = rhs.lengthMatch_;
+  definedKeyWords_ = rhs.definedKeyWords_;
+  name_ = rhs.name_;
+  shortHelp_ = rhs.shortHelp_;
+  longHelp_ = rhs.longHelp_;
+  action_ = rhs.action_;
+  currentKeyWord_ = rhs.currentKeyWord_;
+  display_ = rhs.display_;
+  intValue_ = rhs.intValue_;
+  doubleValue_ = rhs.doubleValue_;
+  stringValue_ = rhs.stringValue_;
+  whereUsed_ = rhs.whereUsed_;
+  fakeKeyWord_ = rhs.fakeKeyWord_;
+  fakeValue_ = rhs.fakeValue_;
+}
+
+//-------------------------------------------------------------------
+// Destructor
+//-------------------------------------------------------------------
+CbcOrClpParam::~CbcOrClpParam()
+{
+}
+
+//----------------------------------------------------------------
+// Assignment operator
+//-------------------------------------------------------------------
+CbcOrClpParam &
+CbcOrClpParam::operator=(const CbcOrClpParam &rhs)
+{
+  if (this != &rhs) {
+    type_ = rhs.type_;
+    lowerDoubleValue_ = rhs.lowerDoubleValue_;
+    upperDoubleValue_ = rhs.upperDoubleValue_;
+    lowerIntValue_ = rhs.lowerIntValue_;
+    upperIntValue_ = rhs.upperIntValue_;
+    lengthName_ = rhs.lengthName_;
+    lengthMatch_ = rhs.lengthMatch_;
+    definedKeyWords_ = rhs.definedKeyWords_;
+    name_ = rhs.name_;
+    shortHelp_ = rhs.shortHelp_;
+    longHelp_ = rhs.longHelp_;
+    action_ = rhs.action_;
+    currentKeyWord_ = rhs.currentKeyWord_;
+    display_ = rhs.display_;
+    intValue_ = rhs.intValue_;
+    doubleValue_ = rhs.doubleValue_;
+    stringValue_ = rhs.stringValue_;
+    whereUsed_ = rhs.whereUsed_;
+    fakeKeyWord_ = rhs.fakeKeyWord_;
+    fakeValue_ = rhs.fakeValue_;
+  }
+  return *this;
+}
+void CbcOrClpParam::gutsOfConstructor()
+{
+  std::string::size_type shriekPos = name_.find('!');
+  lengthName_ = static_cast< unsigned int >(name_.length());
+  if (shriekPos == std::string::npos) {
+    //does not contain '!'
+    lengthMatch_ = lengthName_;
+  } else {
+    lengthMatch_ = static_cast< unsigned int >(shriekPos);
+    name_ = name_.substr(0, shriekPos) + name_.substr(shriekPos + 1);
+    lengthName_--;
+  }
+}
+// Sets value of fake keyword to current size of keywords
+void CbcOrClpParam::setFakeKeyWord(int fakeValue)
+{
+  fakeKeyWord_ = static_cast< int >(definedKeyWords_.size());
+  assert(fakeKeyWord_ > 0);
+  fakeValue_ = fakeValue;
+  assert(fakeValue_ >= 0);
+}
+/* Returns current parameter option position
+   but if fake keyword returns fakeValue_
+*/
+int CbcOrClpParam::currentOptionAsInteger() const
+{
+  int fakeInteger;
+  return currentOptionAsInteger(fakeInteger);
+}
+/* Returns current parameter option position
+   but if fake keyword returns fakeValue_ and sets
+   fakeInteger to value
+*/
+int CbcOrClpParam::currentOptionAsInteger(int &fakeInteger) const
+{
+  fakeInteger = -COIN_INT_MAX;
+  if (fakeKeyWord_ < 0) {
+    return currentKeyWord_;
+  } else if (currentKeyWord_ >= 0 && currentKeyWord_ < fakeKeyWord_) {
+    return currentKeyWord_;
+  } else {
+    // fake
+    if (currentKeyWord_ < 0)
+      fakeInteger = currentKeyWord_ + 1000;
+    else
+      fakeInteger = currentKeyWord_ - 1000;
+    return fakeValue_;
+  }
+}
+// Returns length of name for printing
+int CbcOrClpParam::lengthMatchName() const
+{
+  if (lengthName_ == lengthMatch_)
+    return lengthName_;
+  else
+    return lengthName_ + 2;
+}
+// Insert string (only valid for keywords)
+void CbcOrClpParam::append(std::string keyWord)
+{
+  definedKeyWords_.push_back(keyWord);
+}
+
+int CbcOrClpParam::matches(std::string input) const
+{
+  // look up strings to do more elegantly
+  if (input.length() > lengthName_) {
+    return 0;
+  } else {
+    unsigned int i;
+    for (i = 0; i < input.length(); i++) {
+      if (tolower(name_[i]) != tolower(input[i]))
+        break;
+    }
+    if (i < input.length()) {
+      return 0;
+    } else if (i >= lengthMatch_) {
+      return 1;
+    } else {
+      // matched but too short
+      return 2;
+    }
+  }
+}
+// Returns name which could match
+std::string
+CbcOrClpParam::matchName() const
+{
+  if (lengthMatch_ == lengthName_)
+    return name_;
+  else
+    return name_.substr(0, lengthMatch_) + "(" + name_.substr(lengthMatch_) + ")";
+}
+
+// Returns parameter option which matches (-1 if none)
+int CbcOrClpParam::parameterOption(std::string check) const
+{
+  int numberItems = static_cast< int >(definedKeyWords_.size());
+  if (!numberItems) {
+    return -1;
+  } else {
+    int whichItem = 0;
+    unsigned int it;
+    for (it = 0; it < definedKeyWords_.size(); it++) {
+      std::string thisOne = definedKeyWords_[it];
+      std::string::size_type shriekPos = thisOne.find('!');
+      size_t length1 = thisOne.length();
+      size_t length2 = length1;
+      if (shriekPos != std::string::npos) {
+        //contains '!'
+        length2 = shriekPos;
+        thisOne = thisOne.substr(0, shriekPos) + thisOne.substr(shriekPos + 1);
+        length1 = thisOne.length();
+      }
+      if (check.length() <= length1 && length2 <= check.length()) {
+        unsigned int i;
+        for (i = 0; i < check.length(); i++) {
+          if (tolower(thisOne[i]) != tolower(check[i]))
+            break;
+        }
+        if (i < check.length()) {
+          whichItem++;
+        } else if (i >= length2) {
+          break;
+        }
+      } else {
+        whichItem++;
+      }
+    }
+    if (whichItem < numberItems) {
+      return whichItem;
+    } else {
+      if (fakeKeyWord_ <= 0)
+        return -1;
+      // allow plus or minus
+      int n;
+      if (check.substr(0, 4) == "plus" || check.substr(0, 4) == "PLUS") {
+        n = 4;
+      } else if (check.substr(0, 5) == "minus" || check.substr(0, 5) == "MINUS") {
+        n = 5;
+      } else {
+        return -1;
+      }
+      int value = 0;
+      std::string field = check.substr(n);
+      if (field != "EOL") {
+        const char *start = field.c_str();
+        char *endPointer = NULL;
+        // check valid
+        value = static_cast< int >(strtol(start, &endPointer, 10));
+        if (*endPointer != '\0') {
+          return -1;
+        }
+        if (n == 4)
+          return value + 1000;
+        else
+          return -value - 1000;
+      } else {
+        return -1;
+      }
+    }
+  }
+}
+// Prints parameter options
+void CbcOrClpParam::printOptions() const
+{
+  std::cout << "<Possible options for " << name_ << " are:";
+  unsigned int it;
+  for (it = 0; it < definedKeyWords_.size(); it++) {
+    std::string thisOne = definedKeyWords_[it];
+    std::string::size_type shriekPos = thisOne.find('!');
+    if (shriekPos != std::string::npos) {
+      //contains '!'
+      thisOne = thisOne.substr(0, shriekPos) + "(" + thisOne.substr(shriekPos + 1) + ")";
+    }
+    std::cout << " " << thisOne;
+  }
+  assert(currentKeyWord_ >= 0 && currentKeyWord_ < static_cast< int >(definedKeyWords_.size()));
+  std::string current = definedKeyWords_[currentKeyWord_];
+  std::string::size_type shriekPos = current.find('!');
+  if (shriekPos != std::string::npos) {
+    //contains '!'
+    current = current.substr(0, shriekPos) + "(" + current.substr(shriekPos + 1) + ")";
+  }
+  std::cout << ";\n\tcurrent  " << current << ">" << std::endl;
+}
+// Print action and string
+void CbcOrClpParam::printString() const
+{
+  if (name_ == "directory")
+    std::cout << "Current working directory is " << stringValue_ << std::endl;
+  else if (name_.substr(0, 6) == "printM")
+    std::cout << "Current value of printMask is " << stringValue_ << std::endl;
+  else
+    std::cout << "Current default (if $ as parameter) for " << name_
+              << " is " << stringValue_ << std::endl;
+}
+void CoinReadPrintit(const char *input)
+{
+  int length = static_cast< int >(strlen(input));
+  assert(length <= 10000);
+  char temp[10001];
+  int i;
+  int n = 0;
+  for (i = 0; i < length; i++) {
+    if (input[i] == '\n') {
+      temp[n] = '\0';
+      std::cout << temp << std::endl;
+      n = 0;
+    } else if (n >= 65 && input[i] == ' ') {
+      temp[n] = '\0';
+      std::cout << temp << std::endl;
+      n = 0;
+    } else if (n || input[i] != ' ') {
+      temp[n++] = input[i];
+    }
+  }
+  if (n) {
+    temp[n] = '\0';
+    std::cout << temp << std::endl;
+  }
+}
+// Print Long help
+void CbcOrClpParam::printLongHelp() const
+{
+  if (type_ >= 1 && type_ < 600) {
+    CoinReadPrintit(longHelp_.c_str());
+    if (type_ < CLP_PARAM_INT_SOLVERLOGLEVEL) {
+      printf("<Range of values is %g to %g;\n\tcurrent %g>\n", lowerDoubleValue_, upperDoubleValue_, doubleValue_);
+      assert(upperDoubleValue_ > lowerDoubleValue_);
+    } else if (type_ < CLP_PARAM_STR_DIRECTION) {
+      printf("<Range of values is %d to %d;\n\tcurrent %d>\n", lowerIntValue_, upperIntValue_, intValue_);
+      assert(upperIntValue_ > lowerIntValue_);
+    } else if (type_ < CLP_PARAM_ACTION_DIRECTORY) {
+      printOptions();
+    }
+  }
+}
+#ifdef COIN_HAS_CBC
+int CbcOrClpParam::setDoubleParameter(OsiSolverInterface *model, double value)
+{
+  int returnCode;
+  setDoubleParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage(OsiSolverInterface *model, double value, int &returnCode)
+{
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+      value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+    std::cout << value << " was provided for " << name_ << " - valid range is " << lowerDoubleValue_ << " to " << upperDoubleValue_ << std::endl;
+    returnCode = 1;
+  } else {
+    double oldValue = doubleValue_;
+    doubleValue_ = value;
+    switch (type_) {
+    case CLP_PARAM_DBL_DUALTOLERANCE:
+      model->getDblParam(OsiDualTolerance, oldValue);
+      model->setDblParam(OsiDualTolerance, value);
+      break;
+    case CLP_PARAM_DBL_PRIMALTOLERANCE:
+      model->getDblParam(OsiPrimalTolerance, oldValue);
+      model->setDblParam(OsiPrimalTolerance, value);
+      break;
+    default:
+      break;
+    }
+    sprintf(printArray, "%s was changed from %g to %g",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+  }
+  return printArray;
+}
+#endif
+#ifdef COIN_HAS_CLP
+int CbcOrClpParam::setDoubleParameter(ClpSimplex *model, double value)
+{
+  int returnCode;
+  setDoubleParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage(ClpSimplex *model, double value, int &returnCode)
+{
+  double oldValue = doubleValue_;
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+      value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+    returnCode = 1;
+  } else {
+    sprintf(printArray, "%s was changed from %g to %g",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+    doubleValue_ = value;
+    switch (type_) {
+    case CLP_PARAM_DBL_DUALTOLERANCE:
+      model->setDualTolerance(value);
+      break;
+    case CLP_PARAM_DBL_PRIMALTOLERANCE:
+      model->setPrimalTolerance(value);
+      break;
+    case CLP_PARAM_DBL_ZEROTOLERANCE:
+      model->setSmallElementValue(value);
+      break;
+    case CLP_PARAM_DBL_DUALBOUND:
+      model->setDualBound(value);
+      break;
+    case CLP_PARAM_DBL_PRIMALWEIGHT:
+      model->setInfeasibilityCost(value);
+      break;
+#ifndef COIN_HAS_CBC
+    case CLP_PARAM_DBL_TIMELIMIT:
+      model->setMaximumSeconds(value);
+      break;
+#endif
+    case CLP_PARAM_DBL_OBJSCALE:
+      model->setObjectiveScale(value);
+      break;
+    case CLP_PARAM_DBL_RHSSCALE:
+      model->setRhsScale(value);
+      break;
+    case CLP_PARAM_DBL_PRESOLVETOLERANCE:
+      model->setDblParam(ClpPresolveTolerance, value);
+      break;
+    default:
+      break;
+    }
+  }
+  return printArray;
+}
+double
+CbcOrClpParam::doubleParameter(ClpSimplex *model) const
+{
+  double value;
+  switch (type_) {
+#ifndef COIN_HAS_CBC
+  case CLP_PARAM_DBL_DUALTOLERANCE:
+    value = model->dualTolerance();
+    break;
+  case CLP_PARAM_DBL_PRIMALTOLERANCE:
+    value = model->primalTolerance();
+    break;
+#endif
+  case CLP_PARAM_DBL_ZEROTOLERANCE:
+    value = model->getSmallElementValue();
+    break;
+  case CLP_PARAM_DBL_DUALBOUND:
+    value = model->dualBound();
+    break;
+  case CLP_PARAM_DBL_PRIMALWEIGHT:
+    value = model->infeasibilityCost();
+    break;
+#ifndef COIN_HAS_CBC
+  case CLP_PARAM_DBL_TIMELIMIT:
+    value = model->maximumSeconds();
+    break;
+#endif
+  case CLP_PARAM_DBL_OBJSCALE:
+    value = model->objectiveScale();
+    break;
+  case CLP_PARAM_DBL_RHSSCALE:
+    value = model->rhsScale();
+    break;
+  case CLP_PARAM_DBL_PRESOLVETOLERANCE:
+    value = model->presolveTolerance();
+    break;
+  default:
+    value = doubleValue_;
+    break;
+  }
+  return value;
+}
+int CbcOrClpParam::setIntParameter(ClpSimplex *model, int value)
+{
+  int returnCode;
+  setIntParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage(ClpSimplex *model, int value, int &returnCode)
+{
+  int oldValue = intValue_;
+  if (value < lowerIntValue_ || value > upperIntValue_) {
+    sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+      value, name_.c_str(), lowerIntValue_, upperIntValue_);
+    returnCode = 1;
+  } else {
+    intValue_ = value;
+    sprintf(printArray, "%s was changed from %d to %d",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+    switch (type_) {
+    case CLP_PARAM_INT_SOLVERLOGLEVEL:
+      model->setLogLevel(value);
+      if (value > 2)
+        model->factorization()->messageLevel(8);
+      else
+        model->factorization()->messageLevel(0);
+      break;
+    case CLP_PARAM_INT_MAXFACTOR:
+      model->factorization()->maximumPivots(value);
+      break;
+    case CLP_PARAM_INT_PERTVALUE:
+      model->setPerturbation(value);
+      break;
+    case CLP_PARAM_INT_MAXITERATION:
+      model->setMaximumIterations(value);
+      break;
+    case CLP_PARAM_INT_SPECIALOPTIONS:
+      model->setSpecialOptions(value);
+      break;
+    case CLP_PARAM_INT_RANDOMSEED: {
+      if (value == 0) {
+        double time = fabs(CoinGetTimeOfDay());
+        while (time >= COIN_INT_MAX)
+          time *= 0.5;
+        value = static_cast< int >(time);
+        sprintf(printArray, "using time of day %s was changed from %d to %d",
+          name_.c_str(), oldValue, value);
+      }
+      model->setRandomSeed(value);
+    } break;
+    case CLP_PARAM_INT_MORESPECIALOPTIONS:
+      model->setMoreSpecialOptions(value);
+      break;
+    case CLP_PARAM_INT_VECTOR_MODE:
+      model->setVectorMode(value);
+      break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+    case CBC_PARAM_INT_THREADS:
+      model->setNumberThreads(value);
+      break;
+#endif
+#endif
+    default:
+      break;
+    }
+  }
+  return printArray;
+}
+int CbcOrClpParam::intParameter(ClpSimplex *model) const
+{
+  int value;
+  switch (type_) {
+#ifndef COIN_HAS_CBC
+  case CLP_PARAM_INT_SOLVERLOGLEVEL:
+    value = model->logLevel();
+    break;
+#endif
+  case CLP_PARAM_INT_MAXFACTOR:
+    value = model->factorization()->maximumPivots();
+    break;
+    break;
+  case CLP_PARAM_INT_PERTVALUE:
+    value = model->perturbation();
+    break;
+  case CLP_PARAM_INT_MAXITERATION:
+    value = model->maximumIterations();
+    break;
+  case CLP_PARAM_INT_SPECIALOPTIONS:
+    value = model->specialOptions();
+    break;
+  case CLP_PARAM_INT_RANDOMSEED:
+    value = model->randomNumberGenerator()->getSeed();
+    break;
+  case CLP_PARAM_INT_MORESPECIALOPTIONS:
+    value = model->moreSpecialOptions();
+    break;
+  case CLP_PARAM_INT_VECTOR_MODE:
+    value = model->vectorMode();
+    break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+  case CBC_PARAM_INT_THREADS:
+    value = model->numberThreads();
+    break;
+#endif
+#endif
+  default:
+    value = intValue_;
+    break;
+  }
+  return value;
+}
+#endif
+int CbcOrClpParam::checkDoubleParameter(double value) const
+{
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    std::cout << value << " was provided for " << name_ << " - valid range is " << lowerDoubleValue_ << " to " << upperDoubleValue_ << std::endl;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+#ifdef COIN_HAS_CBC
+double
+CbcOrClpParam::doubleParameter(OsiSolverInterface *model) const
+{
+  double value = 0.0;
+  switch (type_) {
+  case CLP_PARAM_DBL_DUALTOLERANCE:
+    model->getDblParam(OsiDualTolerance, value);
+    break;
+  case CLP_PARAM_DBL_PRIMALTOLERANCE:
+    model->getDblParam(OsiPrimalTolerance, value);
+    break;
+  default:
+    return doubleValue_;
+    break;
+  }
+  return value;
+}
+int CbcOrClpParam::setIntParameter(OsiSolverInterface *model, int value)
+{
+  int returnCode;
+  setIntParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage(OsiSolverInterface *model, int value, int &returnCode)
+{
+  if (value < lowerIntValue_ || value > upperIntValue_) {
+    sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+      value, name_.c_str(), lowerIntValue_, upperIntValue_);
+    returnCode = 1;
+  } else {
+    int oldValue = intValue_;
+    intValue_ = oldValue;
+    switch (type_) {
+    case CLP_PARAM_INT_SOLVERLOGLEVEL:
+      model->messageHandler()->setLogLevel(value);
+      break;
+    default:
+      break;
+    }
+    sprintf(printArray, "%s was changed from %d to %d",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+  }
+  return printArray;
+}
+int CbcOrClpParam::intParameter(OsiSolverInterface *model) const
+{
+  int value = 0;
+  switch (type_) {
+  case CLP_PARAM_INT_SOLVERLOGLEVEL:
+    value = model->messageHandler()->logLevel();
+    break;
+  default:
+    value = intValue_;
+    break;
+  }
+  return value;
+}
+int CbcOrClpParam::setDoubleParameter(CbcModel &model, double value)
+{
+  int returnCode = 0;
+  setDoubleParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage(CbcModel &model, double value, int &returnCode)
+{
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+      value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+    returnCode = 1;
+  } else {
+    double oldValue = doubleValue_;
+    doubleValue_ = value;
+    switch (type_) {
+    case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+      oldValue = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+      model.setDblParam(CbcModel::CbcInfeasibilityWeight, value);
+      break;
+    case CBC_PARAM_DBL_INTEGERTOLERANCE:
+      oldValue = model.getDblParam(CbcModel::CbcIntegerTolerance);
+      model.setDblParam(CbcModel::CbcIntegerTolerance, value);
+      break;
+    case CBC_PARAM_DBL_INCREMENT:
+      oldValue = model.getDblParam(CbcModel::CbcCutoffIncrement);
+      model.setDblParam(CbcModel::CbcCutoffIncrement, value);
+    case CBC_PARAM_DBL_ALLOWABLEGAP:
+      oldValue = model.getDblParam(CbcModel::CbcAllowableGap);
+      model.setDblParam(CbcModel::CbcAllowableGap, value);
+      break;
+    case CBC_PARAM_DBL_GAPRATIO:
+      oldValue = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+      model.setDblParam(CbcModel::CbcAllowableFractionGap, value);
+      break;
+    case CBC_PARAM_DBL_CUTOFF:
+      oldValue = model.getCutoff();
+      model.setCutoff(value);
+      break;
+    case CBC_PARAM_DBL_TIMELIMIT_BAB:
+      oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds);
+      {
+        //OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
+        //ClpSimplex * lpSolver = clpSolver->getModelPtr();
+        //lpSolver->setMaximumSeconds(value);
+        model.setDblParam(CbcModel::CbcMaximumSeconds, value);
+      }
+      break;
+    case CLP_PARAM_DBL_DUALTOLERANCE:
+    case CLP_PARAM_DBL_PRIMALTOLERANCE:
+      setDoubleParameter(model.solver(), value);
+      return 0; // to avoid message
+    default:
+      break;
+    }
+    sprintf(printArray, "%s was changed from %g to %g",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+  }
+  return printArray;
+}
+double
+CbcOrClpParam::doubleParameter(CbcModel &model) const
+{
+  double value;
+  switch (type_) {
+  case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+    value = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+    break;
+  case CBC_PARAM_DBL_INTEGERTOLERANCE:
+    value = model.getDblParam(CbcModel::CbcIntegerTolerance);
+    break;
+  case CBC_PARAM_DBL_INCREMENT:
+    value = model.getDblParam(CbcModel::CbcCutoffIncrement);
+    break;
+  case CBC_PARAM_DBL_ALLOWABLEGAP:
+    value = model.getDblParam(CbcModel::CbcAllowableGap);
+    break;
+  case CBC_PARAM_DBL_GAPRATIO:
+    value = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+    break;
+  case CBC_PARAM_DBL_CUTOFF:
+    value = model.getCutoff();
+    break;
+  case CBC_PARAM_DBL_TIMELIMIT_BAB:
+    value = model.getDblParam(CbcModel::CbcMaximumSeconds);
+    break;
+  case CLP_PARAM_DBL_DUALTOLERANCE:
+  case CLP_PARAM_DBL_PRIMALTOLERANCE:
+    value = doubleParameter(model.solver());
+    break;
+  default:
+    value = doubleValue_;
+    break;
+  }
+  return value;
+}
+int CbcOrClpParam::setIntParameter(CbcModel &model, int value)
+{
+  int returnCode;
+  setIntParameterWithMessage(model, value, returnCode);
+  if (doPrinting && strlen(printArray))
+    std::cout << printArray << std::endl;
+  return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage(CbcModel &model, int value, int &returnCode)
+{
+  if (value < lowerIntValue_ || value > upperIntValue_) {
+    sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+      value, name_.c_str(), lowerIntValue_, upperIntValue_);
+    returnCode = 1;
+  } else {
+    printArray[0] = '\0';
+    if (value == intValue_)
+      return printArray;
+    int oldValue = intValue_;
+    intValue_ = value;
+    switch (type_) {
+    case CLP_PARAM_INT_LOGLEVEL:
+      oldValue = model.messageHandler()->logLevel();
+      model.messageHandler()->setLogLevel(CoinAbs(value));
+      break;
+    case CLP_PARAM_INT_SOLVERLOGLEVEL:
+      oldValue = model.solver()->messageHandler()->logLevel();
+      model.solver()->messageHandler()->setLogLevel(value);
+      break;
+    case CBC_PARAM_INT_MAXNODES:
+      oldValue = model.getIntParam(CbcModel::CbcMaxNumNode);
+      model.setIntParam(CbcModel::CbcMaxNumNode, value);
+      break;
+    case CBC_PARAM_INT_MAXSOLS:
+      oldValue = model.getIntParam(CbcModel::CbcMaxNumSol);
+      model.setIntParam(CbcModel::CbcMaxNumSol, value);
+      break;
+    case CBC_PARAM_INT_MAXSAVEDSOLS:
+      oldValue = model.maximumSavedSolutions();
+      model.setMaximumSavedSolutions(value);
+      break;
+    case CBC_PARAM_INT_STRONGBRANCHING:
+      oldValue = model.numberStrong();
+      model.setNumberStrong(value);
+      break;
+    case CBC_PARAM_INT_NUMBERBEFORE:
+      oldValue = model.numberBeforeTrust();
+      model.setNumberBeforeTrust(value);
+      break;
+    case CBC_PARAM_INT_NUMBERANALYZE:
+      oldValue = model.numberAnalyzeIterations();
+      model.setNumberAnalyzeIterations(value);
+      break;
+    case CBC_PARAM_INT_CUTPASSINTREE:
+      oldValue = model.getMaximumCutPasses();
+      model.setMaximumCutPasses(value);
+      break;
+    case CBC_PARAM_INT_CUTPASS:
+      oldValue = model.getMaximumCutPassesAtRoot();
+      model.setMaximumCutPassesAtRoot(value);
+      break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+    case CBC_PARAM_INT_THREADS:
+      oldValue = model.getNumberThreads();
+      model.setNumberThreads(value);
+      break;
+#endif
+    case CBC_PARAM_INT_RANDOMSEED:
+      oldValue = model.getRandomSeed();
+      model.setRandomSeed(value);
+      break;
+#endif
+    default:
+      break;
+    }
+    sprintf(printArray, "%s was changed from %d to %d",
+      name_.c_str(), oldValue, value);
+    returnCode = 0;
+  }
+  return printArray;
+}
+int CbcOrClpParam::intParameter(CbcModel &model) const
+{
+  int value;
+  switch (type_) {
+  case CLP_PARAM_INT_LOGLEVEL:
+    value = model.messageHandler()->logLevel();
+    break;
+  case CLP_PARAM_INT_SOLVERLOGLEVEL:
+    value = model.solver()->messageHandler()->logLevel();
+    break;
+  case CBC_PARAM_INT_MAXNODES:
+    value = model.getIntParam(CbcModel::CbcMaxNumNode);
+    break;
+  case CBC_PARAM_INT_MAXSOLS:
+    value = model.getIntParam(CbcModel::CbcMaxNumSol);
+    break;
+  case CBC_PARAM_INT_MAXSAVEDSOLS:
+    value = model.maximumSavedSolutions();
+    break;
+  case CBC_PARAM_INT_STRONGBRANCHING:
+    value = model.numberStrong();
+    break;
+  case CBC_PARAM_INT_NUMBERBEFORE:
+    value = model.numberBeforeTrust();
+    break;
+  case CBC_PARAM_INT_NUMBERANALYZE:
+    value = model.numberAnalyzeIterations();
+    break;
+  case CBC_PARAM_INT_CUTPASSINTREE:
+    value = model.getMaximumCutPasses();
+    break;
+  case CBC_PARAM_INT_CUTPASS:
+    value = model.getMaximumCutPassesAtRoot();
+    break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+  case CBC_PARAM_INT_THREADS:
+    value = model.getNumberThreads();
+	break;
+#endif
+  case CBC_PARAM_INT_RANDOMSEED:
+    value = model.getRandomSeed();
+    break;
+#endif
+  default:
+    value = intValue_;
+    break;
+  }
+  return value;
+}
+#endif
+// Sets current parameter option using string
+void CbcOrClpParam::setCurrentOption(const std::string value)
+{
+  int action = parameterOption(value);
+  if (action >= 0)
+    currentKeyWord_ = action;
+#if FLUSH_PRINT_BUFFER > 2
+  if (name_ == "bufferedMode")
+    coinFlushBufferFlag = action;
+#endif
+}
+// Sets current parameter option
+void CbcOrClpParam::setCurrentOption(int value, bool printIt)
+{
+  if (printIt && value != currentKeyWord_)
+    std::cout << "Option for " << name_ << " changed from "
+              << definedKeyWords_[currentKeyWord_] << " to "
+              << definedKeyWords_[value] << std::endl;
+
+#if FLUSH_PRINT_BUFFER > 2
+  if (name_ == "bufferedMode")
+    coinFlushBufferFlag = value;
+#endif
+  currentKeyWord_ = value;
+}
+// Sets current parameter option and returns printable string
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage(int value)
+{
+  if (value != currentKeyWord_) {
+    char current[100];
+    char newString[100];
+    if (currentKeyWord_ >= 0 && (fakeKeyWord_ <= 0 || currentKeyWord_ < fakeKeyWord_))
+      strcpy(current, definedKeyWords_[currentKeyWord_].c_str());
+    else if (currentKeyWord_ < 0)
+      sprintf(current, "minus%d", -currentKeyWord_ - 1000);
+    else
+      sprintf(current, "plus%d", currentKeyWord_ - 1000);
+    if (value >= 0 && (fakeKeyWord_ <= 0 || value < fakeKeyWord_))
+      strcpy(newString, definedKeyWords_[value].c_str());
+    else if (value < 0)
+      sprintf(newString, "minus%d", -value - 1000);
+    else
+      sprintf(newString, "plus%d", value - 1000);
+    sprintf(printArray, "Option for %s changed from %s to %s",
+      name_.c_str(), current, newString);
+#if FLUSH_PRINT_BUFFER > 2
+    if (name_ == "bufferedMode")
+      coinFlushBufferFlag = value;
+#endif
+    currentKeyWord_ = value;
+  } else {
+    printArray[0] = '\0';
+  }
+  return printArray;
+}
+// Sets current parameter option using string with message
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage(const std::string value)
+{
+  int action = parameterOption(value);
+  char current[100];
+  printArray[0] = '\0';
+  if (action >= 0) {
+#if FLUSH_PRINT_BUFFER > 2
+    if (name_ == "bufferedMode")
+      coinFlushBufferFlag = action;
+#endif
+    if (action == currentKeyWord_)
+      return NULL;
+    if (currentKeyWord_ >= 0 && (fakeKeyWord_ <= 0 || currentKeyWord_ < fakeKeyWord_))
+      strcpy(current, definedKeyWords_[currentKeyWord_].c_str());
+    else if (currentKeyWord_ < 0)
+      sprintf(current, "minus%d", -currentKeyWord_ - 1000);
+    else
+      sprintf(current, "plus%d", currentKeyWord_ - 1000);
+    sprintf(printArray, "Option for %s changed from %s to %s",
+      name_.c_str(), current, value.c_str());
+    currentKeyWord_ = action;
+  } else {
+    sprintf(printArray, "Option for %s given illegal value %s",
+      name_.c_str(), value.c_str());
+  }
+  return printArray;
+}
+void CbcOrClpParam::setIntValue(int value)
+{
+  if (value < lowerIntValue_ || value > upperIntValue_) {
+    std::cout << value << " was provided for " << name_ << " - valid range is " << lowerIntValue_ << " to " << upperIntValue_ << std::endl;
+  } else {
+    intValue_ = value;
+  }
+}
+const char *
+CbcOrClpParam::setIntValueWithMessage(int value)
+{
+  printArray[0] = '\0';
+  if (value < lowerIntValue_ || value > upperIntValue_) {
+    sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+      value, name_.c_str(), lowerIntValue_, upperIntValue_);
+  } else {
+    if (value == intValue_)
+      return NULL;
+    sprintf(printArray, "%s was changed from %d to %d",
+      name_.c_str(), intValue_, value);
+    intValue_ = value;
+  }
+  return printArray;
+}
+void CbcOrClpParam::setDoubleValue(double value)
+{
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    std::cout << value << " was provided for " << name_ << " - valid range is " << lowerDoubleValue_ << " to " << upperDoubleValue_ << std::endl;
+  } else {
+    doubleValue_ = value;
+  }
+}
+const char *
+CbcOrClpParam::setDoubleValueWithMessage(double value)
+{
+  printArray[0] = '\0';
+  if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+    sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+      value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+  } else {
+    if (value == doubleValue_)
+      return NULL;
+    sprintf(printArray, "%s was changed from %g to %g",
+      name_.c_str(), doubleValue_, value);
+    doubleValue_ = value;
+  }
+  return printArray;
+}
+void CbcOrClpParam::setStringValue(std::string value)
+{
+  stringValue_ = value;
+}
+static char line[1000];
+static char *where = NULL;
+extern int CbcOrClpRead_mode;
+int CbcOrClpEnvironmentIndex = -1;
+// Alternative to environment
+char *alternativeEnvironment = NULL;
+static size_t fillEnv()
+{
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+  return 0;
+#else
+  // Don't think it will work on Windows
+  char *environ;
+  if (!alternativeEnvironment)
+    environ = getenv("CBC_CLP_ENVIRONMENT");
+  else
+    environ = alternativeEnvironment;
+  size_t length = 0;
+  if (environ) {
+    length = strlen(environ);
+    if (CbcOrClpEnvironmentIndex < static_cast< int >(length)) {
+      // find next non blank
+      char *whereEnv = environ + CbcOrClpEnvironmentIndex;
+      // munch white space
+      while (*whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ')
+        whereEnv++;
+      // copy
+      char *put = line;
+      while (*whereEnv != '\0') {
+        if (*whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ') {
+          break;
+        }
+        *put = *whereEnv;
+        put++;
+        assert(put - line < 1000);
+        whereEnv++;
+      }
+      CbcOrClpEnvironmentIndex = static_cast< int >(whereEnv - environ);
+      *put = '\0';
+      length = strlen(line);
+    } else {
+      length = 0;
+    }
+  }
+  if (!length) {
+    CbcOrClpEnvironmentIndex = -1;
+    if (alternativeEnvironment) {
+      delete[] alternativeEnvironment;
+      alternativeEnvironment = NULL;
+    }
+  }
+  return length;
+#endif
+}
+extern FILE *CbcOrClpReadCommand;
+// Simple read stuff
+std::string
+CoinReadNextField()
+{
+  std::string field;
+  if (!where) {
+    // need new line
+#ifdef COIN_HAS_READLINE
+    if (CbcOrClpReadCommand == stdin) {
+      // Get a line from the user.
+      where = readline(coin_prompt);
+
+      // If the line has any text in it, save it on the history.
+      if (where) {
+        if (*where)
+          add_history(where);
+        strcpy(line, where);
+        free(where);
+      }
+    } else {
+      where = fgets(line, 1000, CbcOrClpReadCommand);
+    }
+#else
+    if (CbcOrClpReadCommand == stdin) {
+      fputs(coin_prompt, stdout);
+      fflush(stdout);
+    }
+    where = fgets(line, 1000, CbcOrClpReadCommand);
+#endif
+    if (!where)
+      return field; // EOF
+    where = line;
+    // clean image
+    char *lastNonBlank = line - 1;
+    while (*where != '\0') {
+      if (*where != '\t' && *where < ' ') {
+        break;
+      } else if (*where != '\t' && *where != ' ') {
+        lastNonBlank = where;
+      }
+      where++;
+    }
+    where = line;
+    *(lastNonBlank + 1) = '\0';
+  }
+  // munch white space
+  while (*where == ' ' || *where == '\t')
+    where++;
+  char *saveWhere = where;
+  while (*where != ' ' && *where != '\t' && *where != '\0')
+    where++;
+  if (where != saveWhere) {
+    char save = *where;
+    *where = '\0';
+    //convert to string
+    field = saveWhere;
+    *where = save;
+  } else {
+    where = NULL;
+    field = "EOL";
+  }
+  return field;
+}
+
+std::string
+CoinReadGetCommand(int argc, const char *argv[])
+{
+  std::string field = "EOL";
+  // say no =
+  afterEquals = "";
+  while (field == "EOL") {
+    if (CbcOrClpRead_mode > 0) {
+      if ((CbcOrClpRead_mode < argc && argv[CbcOrClpRead_mode]) || CbcOrClpEnvironmentIndex >= 0) {
+        if (CbcOrClpEnvironmentIndex < 0) {
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          if (fillEnv()) {
+            field = line;
+          } else {
+            // not there
+            continue;
+          }
+        }
+        if (field == "-") {
+          std::cout << "Switching to line mode" << std::endl;
+          CbcOrClpRead_mode = -1;
+          field = CoinReadNextField();
+        } else if (field[0] != '-') {
+          if (CbcOrClpRead_mode != 2) {
+            // now allow std::cout<<"skipping non-command "<<field<<std::endl;
+            // field="EOL"; // skip
+          } else if (CbcOrClpEnvironmentIndex < 0) {
+            // special dispensation - taken as -import name
+            CbcOrClpRead_mode--;
+            field = "import";
+          }
+        } else {
+          if (field != "--") {
+            // take off -
+            field = field.substr(1);
+          } else {
+            // special dispensation - taken as -import --
+            CbcOrClpRead_mode--;
+            field = "import";
+          }
+        }
+      } else {
+        field = "";
+      }
+    } else {
+      field = CoinReadNextField();
+    }
+  }
+  // if = then modify and save
+  std::string::size_type found = field.find('=');
+  if (found != std::string::npos) {
+    afterEquals = field.substr(found + 1);
+    field = field.substr(0, found);
+  }
+  //std::cout<<field<<std::endl;
+  return field;
+}
+std::string
+CoinReadGetString(int argc, const char *argv[])
+{
+  std::string field = "EOL";
+  if (afterEquals == "") {
+    if (CbcOrClpRead_mode > 0) {
+      if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+        if (CbcOrClpEnvironmentIndex < 0) {
+	  const char * input = argv[CbcOrClpRead_mode];
+	  if (strcmp(input,"--")&&strcmp(input,"stdin")&&
+	      strcmp(input,"stdin_lp")) {
+            field = argv[CbcOrClpRead_mode++];
+          } else {
+            CbcOrClpRead_mode++;
+            // -- means import from stdin
+	    // but allow for other than mps files
+	    // Clp does things in different way !!
+	    if (!strcmp(input,"--"))
+	      field = "-";
+	    else if (!strcmp(input,"stdin"))
+	      field = "-";
+	    else if (!strcmp(input,"stdin_lp"))
+	      field = "-lp";
+	  }
+        } else {
+          fillEnv();
+          field = line;
+        }
+      }
+    } else {
+      field = CoinReadNextField();
+    }
+  } else {
+    field = afterEquals;
+    afterEquals = "";
+  }
+  //std::cout<<field<<std::endl;
+  return field;
+}
+// valid 0 - okay, 1 bad, 2 not there
+int CoinReadGetIntField(int argc, const char *argv[], int *valid)
+{
+  std::string field = "EOL";
+  if (afterEquals == "") {
+    if (CbcOrClpRead_mode > 0) {
+      if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+        if (CbcOrClpEnvironmentIndex < 0) {
+          // may be negative value so do not check for -
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          fillEnv();
+          field = line;
+        }
+      }
+    } else {
+      field = CoinReadNextField();
+    }
+  } else {
+    field = afterEquals;
+    afterEquals = "";
+  }
+  long int value = 0;
+  //std::cout<<field<<std::endl;
+  if (field != "EOL") {
+    const char *start = field.c_str();
+    char *endPointer = NULL;
+    // check valid
+    value = strtol(start, &endPointer, 10);
+    if (*endPointer == '\0') {
+      *valid = 0;
+    } else {
+      *valid = 1;
+      std::cout << "String of " << field;
+    }
+  } else {
+    *valid = 2;
+  }
+  return static_cast< int >(value);
+}
+double
+CoinReadGetDoubleField(int argc, const char *argv[], int *valid)
+{
+  std::string field = "EOL";
+  if (afterEquals == "") {
+    if (CbcOrClpRead_mode > 0) {
+      if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+        if (CbcOrClpEnvironmentIndex < 0) {
+          // may be negative value so do not check for -
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          fillEnv();
+          field = line;
+        }
+      }
+    } else {
+      field = CoinReadNextField();
+    }
+  } else {
+    field = afterEquals;
+    afterEquals = "";
+  }
+  double value = 0.0;
+  //std::cout<<field<<std::endl;
+  if (field != "EOL") {
+    const char *start = field.c_str();
+    char *endPointer = NULL;
+    // check valid
+    value = strtod(start, &endPointer);
+    if (*endPointer == '\0') {
+      *valid = 0;
+    } else {
+      *valid = 1;
+      std::cout << "String of " << field;
+    }
+  } else {
+    *valid = 2;
+  }
+  return value;
+}
+/*
+  Subroutine to establish the cbc parameter array. See the description of
+  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
+*/
+void establishParams(std::vector< CbcOrClpParam > &parameters)
+{
+  parameters.clear();
+  parameters.push_back(CbcOrClpParam("?", "For help", CBC_PARAM_GENERALQUERY, 7, 0));
+  parameters.push_back(CbcOrClpParam("???", "For help", CBC_PARAM_FULLGENERALQUERY, 7, 0));
+  parameters.push_back(CbcOrClpParam("-", "From stdin", CLP_PARAM_ACTION_STDIN, 3, 0));
+
+// some help strings that repeat for many options
+#define CUTS_LONGHELP \
+  "Value 'on' enables the cut generator and CBC will try it in the branch and cut tree (see cutDepth on how to fine tune the behavior). " \
+  "Value 'root' lets CBC run the cut generator generate only at the root node. " \
+  "Value 'ifmove' lets CBC use the cut generator in the tree if it looks as if it is doing some good and moves the objective value. " \
+  "Value 'forceon' turns on the cut generator and forces CBC to use it at every node."
+#define HEURISTICS_LONGHELP \
+  "Value 'on' means to use the heuristic in each node of the tree, i.e. after preprocessing. " \
+  "Value 'before' means use the heuristic only if option doHeuristics is used. " \
+  "Value 'both' means to use the heuristic if option doHeuristics is used and during solve."
+
+#if defined(ABC_INHERIT) || ABOCA_LITE
+  CbcOrClpParam paramAboca("abc", "Whether to visit Aboca", "off", CLP_PARAM_STR_ABCWANTED, 7, 0);
+  paramAboca.append("one");
+  paramAboca.append("two");
+  paramAboca.append("three");
+  paramAboca.append("four");
+  paramAboca.append("five");
+  paramAboca.append("six");
+  paramAboca.append("seven");
+  paramAboca.append("eight");
+  paramAboca.append("on");
+  paramAboca.append("decide");
+  paramAboca.setFakeKeyWord(10);
+  paramAboca.setLonghelp(
+    "Decide whether to use A Basic Optimization Code (Accelerated?) \
+and whether to try going parallel!");
+  parameters.push_back(paramAboca);
+#endif
+  {
+    CbcOrClpParam p("allC!ommands", "Whether to print less used commands",
+      "no", CLP_PARAM_STR_ALLCOMMANDS);
+
+    p.append("more");
+    p.append("all");
+    p.setLonghelp(
+      "For the sake of your sanity, only the more useful and simple commands \
+are printed out on ?.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("allow!ableGap", "Stop when gap between best possible and \
+best less than this",
+      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ALLOWABLEGAP);
+    p.setDoubleValue(0.0);
+    p.setLonghelp(
+      "If the gap between best known solution and the best possible solution is less than this \
+value, then the search will be terminated.  Also see ratioGap.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("allS!lack", "Set basis back to all slack and reset solution",
+      CLP_PARAM_ACTION_ALLSLACK, 3);
+    p.setLonghelp(
+      "Mainly useful for tuning purposes.  Normally the first dual or primal will be using an all slack \
+basis anyway.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("artif!icialCost", "Costs >= this treated as artificials in feasibility pump",
+      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
+    p.setDoubleValue(0.0);
+    p.setLonghelp(
+      "A value of 0.0 means off. Otherwise, variables with costs >= this are treated as artificial variables and fixed to lower bound in feasibility pump.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("auto!Scale", "Whether to scale objective, rhs and bounds of problem if they look odd",
+      "off", CLP_PARAM_STR_AUTOSCALE, 7, 0);
+    p.append("on");
+    p.setLonghelp(
+      "If you think you may get odd objective values or large equality rows etc then\
+ it may be worth setting this true.  It is still experimental and you may prefer\
+ to use objective!Scale and rhs!Scale.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("barr!ier", "Solve using primal dual predictor corrector algorithm",
+      CLP_PARAM_ACTION_BARRIER);
+    p.setLonghelp(
+      "This command solves the current model using the  primal dual predictor \
+corrector algorithm.  You may want to link in an alternative \
+ordering and factorization.  It will also solve models \
+with quadratic objectives.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("basisI!n", "Import basis from bas file",
+      CLP_PARAM_ACTION_BASISIN, 3);
+    p.setLonghelp(
+      "This will read an MPS format basis file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  If you have libz then it can read compressed\
+ files 'xxxxxxxx.gz' or xxxxxxxx.bz2.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("basisO!ut", "Export basis as bas file",
+      CLP_PARAM_ACTION_BASISOUT);
+
+    p.setLonghelp(
+      "This will write an MPS format basis file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.bas'.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("biasLU", "Whether factorization biased towards U",
+      "UU", CLP_PARAM_STR_BIASLU, 2, 0);
+
+    p.append("UX");
+    p.append("LX");
+    p.append("LL");
+    p.setCurrentOption("LX");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("branch!AndCut", "Do Branch and Cut",
+      CBC_PARAM_ACTION_BAB);
+    p.setLonghelp(
+      "This does branch and cut.  There are many parameters which can affect the performance.  \
+First just try with default settings and look carefully at the log file.  Did cuts help?  Did they take too long?  \
+Look at output to see which cuts were effective and then do some tuning.  You will see that the \
+options for cuts are off, on, root and ifmove, forceon.  Off is \
+obvious. " CUTS_LONGHELP " For probing, forceonbut just does fixing probing in tree - not strengthening etc.  \
+If pre-processing reduced the size of the \
+problem or strengthened many coefficients then it is probably wise to leave it on.  Switch off heuristics \
+which did not provide solutions.  The other major area to look at is the search.  Hopefully good solutions \
+were obtained fairly early in the search so the important point is to select the best variable to branch on.  \
+See whether strong branching did a good job - or did it just take a lot of iterations.  Adjust the strongBranching \
+and trustPseudoCosts parameters.  If cuts did a good job, then you may wish to \
+have more rounds of cuts - see passC!uts and passT!ree.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("bscale", "Whether to scale in barrier (and ordering speed)",
+      "off", CLP_PARAM_STR_BARRIERSCALE, 7, 0);
+    p.append("on");
+    p.append("off1");
+    p.append("on1");
+    p.append("off2");
+    p.append("on2");
+    parameters.push_back(p);
+  }
+#if FLUSH_PRINT_BUFFER > 2
+  {
+    CbcOrClpParam p("buff!eredMode", "Whether to flush print buffer",
+      "on", CLP_PARAM_STR_BUFFER_MODE);
+
+    p.append("off");
+    p.setLonghelp(
+      "Default is on, off switches on unbuffered output");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("chol!esky", "Which cholesky algorithm",
+      "native", CLP_PARAM_STR_CHOLESKY, 7);
+
+    p.append("dense");
+    //#ifdef FOREIGN_BARRIER
+#ifdef COIN_HAS_WSMP
+    p.append("fudge!Long");
+    p.append("wssmp");
+#else
+    p.append("fudge!Long_dummy");
+    p.append("wssmp_dummy");
+#endif
+#if defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(COIN_HAS_GLPK)
+    p.append("Uni!versityOfFlorida");
+#else
+    p.append("Uni!versityOfFlorida_dummy");
+#endif
+#ifdef TAUCS_BARRIER
+    p.append("Taucs");
+#else
+    p.append("Taucs_dummy");
+#endif
+#ifdef COIN_HAS_MUMPS
+    p.append("Mumps");
+#else
+    p.append("Mumps_dummy");
+#endif
+#ifdef PARDISO_BARRIER
+    p.append("Pardiso");
+#else
+    p.append("Pardiso_dummy");
+#endif
+    p.setLonghelp(
+      "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
+The native ordering and factorization is not state of the art, although acceptable.  \
+You may want to link in one from another source.  See Makefile.locations for some \
+possibilities.");
+
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+ {
+    CbcOrClpParam p("clique!Cuts", "Whether to use Clique cuts",
+      "off", CBC_PARAM_STR_CLIQUECUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.setLonghelp(CUTS_LONGHELP
+     " Reference: https://github.com/coin-or/Cgl/wiki/CglClique");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("combine!Solutions", "Whether to use combine solution heuristic",
+      "off", CBC_PARAM_STR_COMBINE);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("onquick");
+    p.append("bothquick");
+    p.append("beforequick");
+    p.setLonghelp(
+      "This heuristic does branch and cut on given problem by just \
+using variables which have appeared in one or more solutions. \
+It is obviously only tried after two or more solutions have been found. "
+      HEURISTICS_LONGHELP);
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("combine2!Solutions", "Whether to use crossover solution heuristic",
+      "off", CBC_PARAM_STR_CROSSOVER2);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(
+      "This heuristic does branch and cut on the problem given by \
+fixing variables which have the same value in two or more solutions. \
+It obviously only tries after two or more solutions. "
+      HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("constraint!fromCutoff", "Whether to use cutoff as constraint",
+      "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
+
+    p.append("on");
+    p.append("variable");
+    p.append("forcevariable");
+    p.append("conflict");
+    p.setLonghelp(
+      "For some problems, cut generators and general branching work better if the problem would be infeasible if the cost is too high. "
+      "If this option is enabled, the objective function is added as a constraint which right hand side is set to the current cutoff value (objective value of best known solution)");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cost!Strategy", "How to use costs for branching priorities",
+      "off", CBC_PARAM_STR_COSTSTRATEGY);
+
+    p.append("pri!orities");
+    p.append("column!Order?");
+    p.append("01f!irst?");
+    p.append("01l!ast?");
+    p.append("length!?");
+    p.append("singletons");
+    p.append("nonzero");
+    p.append("general!Force?");
+    p.setLonghelp(
+      "Value 'priorities' assigns highest priority to variables with largest absolute cost. This primitive strategy can be surprisingly effective. "
+      "Value 'columnorder' assigns the priorities 1, 2, 3, ... with respect to the column ordering. "
+      "Value '01first' ('01last') assignes two sets of priorities such that binary variables get high (low) priority. "
+      "Value 'length' assigns high priority to variables that occur in many equations. ");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cplex!Use", "Whether to use Cplex!",
+      "off", CBC_PARAM_STR_CPX);
+    p.append("on");
+    p.setLonghelp(
+      " If the user has Cplex, but wants to use some of Cbc's heuristics \
+then you can!  If this is on, then Cbc will get to the root node and then \
+hand over to Cplex.  If heuristics find a solution this can be significantly \
+quicker.  You will probably want to switch off Cbc's cuts as Cplex thinks \
+they are genuine constraints.  It is also probable that you want to switch \
+off preprocessing, although for difficult problems it is worth trying \
+both.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("cpp!Generate", "Generates C++ code",
+      -1, 50000, CLP_PARAM_INT_CPP, 1);
+    p.setLonghelp(
+      "Once you like what the stand-alone solver does then this allows \
+you to generate user_driver.cpp which approximates the code.  \
+0 gives simplest driver, 1 generates saves and restores, 2 \
+generates saves and restores even for variables at default value. \
+4 bit in cbc generates size dependent code rather than computed values.  \
+This is now deprecated as you can call stand-alone solver - see \
+Cbc/examples/driver4.cpp.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("crash", "Whether to create basis for problem",
+      "off", CLP_PARAM_STR_CRASH);
+
+    p.append("on");
+    p.append("so!low_halim");
+    p.append("lots");
+#ifdef CLP_INHERIT_MODE
+    p.append("dual");
+    p.append("dw");
+    p.append("idiot");
+#else
+    p.append("idiot1");
+    p.append("idiot2");
+    p.append("idiot3");
+    p.append("idiot4");
+    p.append("idiot5");
+    p.append("idiot6");
+    p.append("idiot7");
+#endif
+    p.setLonghelp(
+      "If crash is set to 'on' and there is an all slack basis then Clp will flip or put structural\
+     variables into the basis with the aim of getting dual feasible.  On average, dual simplex seems to perform\
+     better without it and there are alternative types of 'crash' for primal simplex, e.g. 'idiot' or 'sprint'. \
+    A variant due to Solow and Halim which is as 'on' but just flips is also available.");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cross!over", "Whether to get a basic solution with the simplex algorithm after the barrier algorithm finished",
+      "on", CLP_PARAM_STR_CROSSOVER);
+    p.append("off");
+    p.append("maybe");
+    p.append("presolve");
+    p.setLonghelp(
+      "Interior point algorithms do not obtain a basic solution.\
+ This option will crossover to a basic solution suitable for ranging or branch and cut.  With the current state \
+of the solver for quadratic programs it may be a good idea to switch off crossover for this case (and maybe \
+presolve as well) - the option 'maybe' does this.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("csv!Statistics", "Create one line of statistics",
+      CLP_PARAM_ACTION_CSVSTATISTICS, 2, 1);
+    p.setLonghelp(
+      "This appends statistics to given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  Adds header if file empty or does not exist.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cutD!epth", "Depth in tree at which to do cuts",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_CUTDEPTH);
+    p.setLonghelp(
+      "Cut generators may be off, on, on only at the root node, or on if they look useful. \
+      Setting this option to a positive value K let CBC call a cutgenerator on a node whenever the depth in the tree is a multiple of K. \
+      The default of -1 lets CBC decide.");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cutL!ength", "Length of a cut",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_CUTLENGTH);
+    p.setLonghelp("At present this only applies to Gomory cuts. -1 (default) leaves as is. \
+Any value >0 says that all cuts <= this length can be generated both at \
+root node and in tree. 0 says to use some dynamic lengths.  If value >=10,000,000 \
+then the length in tree is value%10000000 - so 10000100 means unlimited length \
+at root and 100 in tree.");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cuto!ff", "Bound on the objective value for all solutions",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_CUTOFF);
+    p.setDoubleValue(1.0e50);
+    p.setLonghelp(
+      "All solutions must have a better objective value (in a minimization sense) than the value of this option.  \
+CBC also updates this value whenever it obtains a solution to the value of \
+the objective function of the solution minus the cutoff increment.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("cuts!OnOff", "Switches all cut generators on or off",
+      "off", CBC_PARAM_STR_CUTSSTRATEGY);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.setLonghelp(
+      "This can be used to switch on or off all cut generators (apart from Reduce and Split). "
+      "Then one can turn individual ones off or on. "
+      CUTS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("debug!In", "read valid solution from file",
+      CLP_PARAM_ACTION_DEBUG, 7, 1);
+
+    p.setLonghelp(
+      "This will read a solution file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.\n\n\
+If set to create it will create a file called debug.file  after search.\n\n\
+The idea is that if you suspect a bad cut generator \
+you can do a good run with debug set to 'create' and then switch on the cuts you suspect and \
+re-run with debug set to 'debug.file'  The create case has same effect as saveSolution.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("decomp!ose", "Whether to try decomposition",
+      -COIN_INT_MAX, COIN_INT_MAX, CLP_PARAM_INT_DECOMPOSE_BLOCKS, 1);
+    p.setLonghelp(
+      "0 - off, 1 choose blocks >1 use as blocks \
+Dantzig Wolfe if primal, Benders if dual \
+- uses sprint pass for number of passes");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#if CLP_MULTIPLE_FACTORIZATIONS > 0
+  {
+    CbcOrClpParam p("dense!Threshold", "Threshold for using dense factorization",
+      -1, 10000, CBC_PARAM_INT_DENSE, 1);
+    p.setLonghelp(
+      "If processed problem <= this use dense factorization");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+#endif
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("depth!MiniBab", "Depth at which to try mini branch-and-bound",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_DEPTHMINIBAB);
+
+    p.setIntValue(-1);
+    p.setLonghelp(
+      "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
+means use Cplex if it is linked in.  Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 \
+(so -3 will use this at depth>=1).  This mode is only switched on after 500 nodes.  If you really want to switch it off for small problems then set \
+this to -999.  If >=0 the value doesn't matter very much.  The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5.  \
+The actual logic is too twisted to describe here.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dextra3", "Extra double parameter 3",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA3, 0);
+    p.setDoubleValue(0.0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dextra4", "Extra double parameter 4",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA4, 0);
+    p.setDoubleValue(0.0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dextra4", "Extra double parameter 5",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA5, 0);
+    p.setDoubleValue(0.0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("Dins", "Whether to try Distance Induced Neighborhood Search",
+      "off", CBC_PARAM_STR_DINS);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("often");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("direction", "Minimize or Maximize",
+      "min!imize", CLP_PARAM_STR_DIRECTION);
+    p.append("max!imize");
+    p.append("zero");
+    p.setLonghelp(
+      "The default is minimize - use 'direction maximize' for maximization.\n\
+You can also use the parameters 'maximize' or 'minimize'.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("directory", "Set Default directory for import etc.",
+      CLP_PARAM_ACTION_DIRECTORY);
+    p.setLonghelp(
+      "This sets the directory which import, export, saveModel, restoreModel etc will use.\
+  It is initialized to './'");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dirSample", "Set directory where the COIN-OR sample problems are.",
+      CLP_PARAM_ACTION_DIRSAMPLE, 7, 1);
+
+    p.setLonghelp(
+      "This sets the directory where the COIN-OR sample problems reside. It is\
+ used only when -unitTest is passed to clp. clp will pick up the test problems\
+ from this directory.\
+ It is initialized to '../../Data/Sample'");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dirNetlib", "Set directory where the netlib problems are.",
+      CLP_PARAM_ACTION_DIRNETLIB, 7, 1);
+
+    p.setLonghelp(
+      "This sets the directory where the netlib problems reside. One can get\
+ the netlib problems from COIN-OR or from the main netlib site. This\
+ parameter is used only when -netlib is passed to clp. clp will pick up the\
+ netlib problems from this directory. If clp is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/Netlib'");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dirMiplib", "Set directory where the miplib 2003 problems are.",
+      CBC_PARAM_ACTION_DIRMIPLIB, 7, 1);
+
+    p.setLonghelp(
+      "This sets the directory where the miplib 2003 problems reside. One can\
+ get the miplib problems from COIN-OR or from the main miplib site. This\
+ parameter is used only when -miplib is passed to cbc. cbc will pick up the\
+ miplib problems from this directory. If cbc is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/miplib3'");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("diveO!pt", "Diving options",
+      -1, 200000, CBC_PARAM_INT_DIVEOPT, 1);
+    p.setLonghelp(
+      "If >2 && <20 then modify diving options - \
+	 \n\t3 only at root and if no solution,  \
+	 \n\t4 only at root and if this heuristic has not got solution, \
+	 \n\t5 decay only if no solution, \
+	 \n\t6 if depth <3 or decay, \
+	 \n\t7 run up to 2 times if solution found 4 otherwise, \
+	 \n\t>10 All only at root (DivingC normal as value-10), \
+	 \n\t>20 All with value-20).");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("diveS!olves", "Diving solve option",
+      -1, 200000, CBC_PARAM_INT_DIVEOPTSOLVES, 1);
+
+    p.setLonghelp(
+      "If >0 then do up to this many solves. However, the last digit is ignored \
+and used for extra options: \
+      1-3 enables fixing of satisfied integer variables (but not at bound), \
+      where 1 switches this off for that dive if the dive goes infeasible, \
+      and 2 switches it off permanently if the dive goes infeasible.");
+    p.setIntValue(100);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingS!ome", "Whether to try Diving heuristics",
+      "off", CBC_PARAM_STR_DIVINGS);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(
+      "This switches on a random diving heuristic at various times. \
+One may prefer to individually turn diving heuristics on or off. "
+      HEURISTICS_LONGHELP);
+// C - Coefficient, F - Fractional, G - Guided, L - LineSearch, P - PseudoCost, V - VectorLength.
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingC!oefficient", "Whether to try Coefficient diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGC);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingF!ractional", "Whether to try Fractional diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGF);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingG!uided", "Whether to try Guided diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGG);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingL!ineSearch", "Whether to try Linesearch diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGL);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingP!seudoCost", "Whether to try Pseudocost diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGP);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("DivingV!ectorLength", "Whether to try Vectorlength diving heuristic",
+      "off", CBC_PARAM_STR_DIVINGV);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("doH!euristic", "Do heuristics before any preprocessing",
+      CBC_PARAM_ACTION_DOHEURISTIC, 3);
+    p.setLonghelp(
+      "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
+Only those heuristics with 'both' or 'before' set will run.  \
+Doing this may also set cutoff, which can help with preprocessing.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("dualB!ound", "Initially algorithm acts as if no \
+gap between bounds exceeds this value",
+      1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALBOUND);
+    p.setLonghelp(
+      "The dual algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal.  If a problem has both upper and\
+ lower bounds then it is trivial to get dual feasible by setting non basic variables\
+ to correct bound.  If the gap between the upper and lower bounds of a variable is more\
+ than the value of dualBound Clp introduces fake bounds so that it can make the problem\
+ dual feasible.  This has the same effect as a composite objective function in the\
+ primal algorithm.  Too high a value may mean more iterations, while too low a bound means\
+ the code may go all the way and then have to increase the bounds.  OSL had a heuristic to\
+ adjust bounds, maybe we need that here.");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dualize", "Solves dual reformulation",
+      0, 4, CLP_PARAM_INT_DUALIZE, 1);
+    p.setLonghelp(
+      "Don't even think about it.");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dualP!ivot", "Dual pivot choice algorithm",
+      "auto!matic", CLP_PARAM_STR_DUALPIVOT, 7, 1);
+    p.append("dant!zig");
+    p.append("partial");
+    p.append("steep!est");
+    p.append("PEsteep!est");
+    p.append("PEdantzig");
+    p.setLonghelp(
+      "The Dantzig method is simple but its use is deprecated.  Steepest is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while automatic decides at each iteration based on information\
+ about the factorization.\
+ The PE variants add the Positive Edge criterion. \
+ This selects incoming variables to try to avoid degenerate moves. See also option psi.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("dualS!implex", "Do dual simplex algorithm",
+      CLP_PARAM_ACTION_DUALSIMPLEX);
+    p.setLonghelp(
+      "This command solves the continuous relaxation of the current model using the dual steepest edge algorithm.\
+The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by dual pivot method, fake bound on variables and dual and primal tolerances.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("dualT!olerance", "For an optimal solution \
+no dual infeasibility may exceed this value",
+      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_DUALTOLERANCE);
+    p.setLonghelp(
+      "Normally the default tolerance is fine, but one may want to increase it a\
+ bit if the dual simplex algorithm seems to be having a hard time.  One method which can be faster is \
+to use a large tolerance e.g. 1.0e-4 and the dual simplex algorithm and then to clean up the problem using the primal simplex algorithm with the \
+correct tolerance (remembering to switch off presolve for this final short clean up phase).");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("dw!Heuristic", "Whether to try Dantzig Wolfe heuristic",
+      "off", CBC_PARAM_STR_DW);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(
+      "This heuristic is very very compute intensive. It tries to find a Dantzig Wolfe structure and use that. "
+      HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("either!Simplex", "Do dual or primal simplex algorithm",
+      CLP_PARAM_ACTION_EITHERSIMPLEX);
+    p.setLonghelp(
+      "This command solves the continuous relaxation of the current model using the dual or primal algorithm,\
+ based on a dubious analysis of model.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("end", "Stops clp execution",
+      CLP_PARAM_ACTION_EXIT);
+    p.setLonghelp(
+      "This stops execution ; end, exit, quit and stop are synonyms");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("environ!ment", "Read commands from environment",
+      CLP_PARAM_ACTION_ENVIRONMENT, 7, 0);
+    p.setLonghelp(
+      "This starts reading from environment variable CBC_CLP_ENVIRONMENT.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("error!sAllowed", "Whether to allow import errors",
+      "off", CLP_PARAM_STR_ERRORSALLOWED, 3);
+
+    p.append("on");
+    p.setLonghelp(
+      "The default is not to use any model which had errors when reading the mps file.\
+  Setting this to 'on' will allow all errors from which the code can recover\
+ simply by ignoring the error.  There are some errors from which the code can not recover \
+e.g. no ENDATA.  This has to be set before import i.e. -errorsAllowed on -import xxxxxx.mps.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("exit", "Stops clp execution",
+      CLP_PARAM_ACTION_EXIT);
+    p.setLonghelp(
+      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("exper!iment", "Whether to use testing features",
+      -1, 200000, CBC_PARAM_INT_EXPERIMENT, 0);
+    p.setLonghelp(
+      "Defines how adventurous you want to be in using new ideas. \
+0 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!");
+
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("expensive!Strong", "Whether to do even more strong branching",
+      0, COIN_INT_MAX, CBC_PARAM_INT_STRONG_STRATEGY, 0);
+
+    p.setLonghelp(
+      "Strategy for extra strong branching. \
+0 is normal strong branching. \
+1, 2, 4, and 6 does strong branching on all fractional variables if \
+at the root node (1), \
+at depth less than modifier (2), \
+objective equals best possible (4), or \
+at depth less than modifier and objective equals best possible (6). \
+11, 12, 14, and 16 are like 1, 2, 4, and 6, respecitively, but do strong branching on all integer (incl. non-fractional) variables. \
+Values >= 100 are used to specify a depth limit (value/100), otherwise 5 is used. \
+If the values >= 100, then above rules are applied to value%100.");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("export", "Export model as mps file",
+      CLP_PARAM_ACTION_EXPORT);
+
+    p.setLonghelp(
+      "This will write an MPS format file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.mps'.  \
+It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn.  This can be done by setting 'keepnames' off before importing mps file.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("extra1", "Extra integer parameter 1",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA1, 0);
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("extra2", "Extra integer parameter 2",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA2, 0);
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("extra3", "Extra integer parameter 3",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA3, 0);
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("extra4", "Extra integer parameter 4",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA4, 0);
+
+    p.setIntValue(-1);
+    p.setLonghelp(
+      "This switches on yet more special options!! \
+The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
+means use until a solution is found.  The next two digits say what sort \
+of dual information to use.  After that it goes back to powers of 2 so -\n\
+\n\t1000 - switches on experimental hotstart\n\
+\n\t2,4,6000 - switches on experimental methods of stopping cuts\n\
+\n\t8000 - increase minimum drop gradually\n\
+\n\t16000 - switches on alternate gomory criterion");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("extraV!ariables", "Allow creation of extra integer variables",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
+    p.setIntValue(0);
+    p.setLonghelp(
+      "Switches on a trivial re-formulation that introduces extra integer variables to group together variables with same cost.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("fact!orization", "Which factorization to use",
+      "normal", CLP_PARAM_STR_FACTORIZATION);
+    p.append("dense");
+    p.append("simple");
+    p.append("osl");
+    p.setLonghelp(
+#ifndef ABC_INHERIT
+      "The default is to use the normal CoinFactorization, but \
+other choices are a dense one, OSL's, or one designed for small problems."
+#else
+      "Normally the default is to use the normal CoinFactorization, but \
+other choices are a dense one, OSL's, or one designed for small problems. \
+However if at Aboca then the default is CoinAbcFactorization and other choices are \
+a dense one, one designed for small problems or if enabled a long factorization."
+#endif
+    );
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("fakeB!ound", "All bounds <= this value - DEBUG",
+      1.0, 1.0e15, CLP_PARAM_ACTION_FAKEBOUND, 0);
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("feas!ibilityPump", "Whether to try the Feasibility Pump heuristic",
+      "off", CBC_PARAM_STR_FPUMP);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(
+      "This heuristic is due to Fischetti, Glover, and Lodi \
+and uses a sequence of LPs to try and get an integer feasible solution. \
+Some fine tuning is available by options passFeasibilityPump and pumpTune. "
+      HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("fix!OnDj", "Try heuristic based on fixing variables with \
+reduced costs greater than this",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DJFIX, 1);
+    p.setLonghelp(
+      "If this is set integer variables with reduced costs greater than this will be fixed \
+before branch and bound - use with extreme caution!");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("flow!CoverCuts", "Whether to use Flow Cover cuts",
+      "off", CBC_PARAM_STR_FLOWCUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.setFakeKeyWord(3);
+    p.setLonghelp(CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglFlowCover"); // Can also enter testing values by plusnn (==ifmove)
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("force!Solution", "Whether to use given solution as crash for BAB",
+      -1, 20000000, CLP_PARAM_INT_USESOLUTION);
+    p.setIntValue(-1);
+    p.setLonghelp(
+      "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
+If 0 then just tries to set as best solution \
+If >1 then also does that many nodes on fixed problem.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("fraction!forBAB", "Fraction in feasibility pump",
+      1.0e-5, 1.1, CBC_PARAM_DBL_SMALLBAB, 1);
+    p.setDoubleValue(0.5);
+    p.setLonghelp(
+      "After a pass in the feasibility pump, variables which have not moved \
+about are fixed and if the preprocessed model is smaller than this fraction of the original problem, \
+a few nodes of branch and bound are done on the reduced problem.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("gamma!(Delta)", "Whether to regularize barrier",
+      "off", CLP_PARAM_STR_GAMMA, 7, 1);
+    p.append("on");
+    p.append("gamma");
+    p.append("delta");
+    p.append("onstrong");
+    p.append("gammastrong");
+    p.append("deltastrong");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("GMI!Cuts", "Whether to use alternative Gomory cuts",
+      "off", CBC_PARAM_STR_GMICUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("endonly");
+    p.append("long");
+    p.append("longroot");
+    p.append("longifmove");
+    p.append("forceLongOn");
+    p.append("longendonly");
+    p.setLonghelp(CUTS_LONGHELP
+      " This version is by Giacomo Nannicini and may be more robust than gomoryCuts.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("gomory!Cuts", "Whether to use Gomory cuts",
+      "off", CBC_PARAM_STR_GOMORYCUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.append("forceandglobal");
+    p.append("forceLongOn");
+    p.append("long");
+    p.setLonghelp(
+      "The original cuts - beware of imitations!  Having gone out of favor, \
+they are now more fashionable as LP solvers are more robust and they interact well \
+with other cuts.  They will almost always give cuts (although in this executable \
+they are limited as to number of variables in cut).  However the cuts may be dense \
+so it is worth experimenting (Long allows any length). "
+    CUTS_LONGHELP
+    " Reference: https://github.com/coin-or/Cgl/wiki/CglGomory");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("greedy!Heuristic", "Whether to use a greedy heuristic",
+      "off", CBC_PARAM_STR_GREEDY);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    //p.append("root");
+    p.setLonghelp(
+      "This heuristic tries to obtain a feasible solution by just fixing a percentage of variables and then try a small branch and cut run. "
+      HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("gsolu!tion", "Puts glpk solution to file",
+      CLP_PARAM_ACTION_GMPL_SOLUTION);
+
+    p.setLonghelp(
+      "Will write a glpk solution file to the given file name.  It will use the default \
+directory given by 'directory'.  A name of '$' will use the previous value for the \
+name.  This is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
+If problem created from gmpl model - will do any reports.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("guess", "Guesses at good parameters", CLP_PARAM_ACTION_GUESS, 7);
+    p.setLonghelp(
+    "This looks at model statistics and does an initial solve \
+setting some parameters which may help you to think of possibilities.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("heur!isticsOnOff", "Switches most primal heuristics on or off",
+      "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
+    p.append("on");
+    p.setLonghelp(
+      "This option can be used to switch on or off all heuristics that search for feasible solutions,\
+      except for the local tree search, as it dramatically alters the search.\
+      Then individual heuristics can be turned off or on.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("help", "Print out version, non-standard options and some help",
+      CLP_PARAM_ACTION_HELP, 3);
+    p.setLonghelp(
+      "This prints out some help to get user started.  If you have printed this then \
+you should be past that stage:-)");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("hOp!tions", "Heuristic options",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_HOPTIONS, 1);
+    p.setIntValue(0);
+    p.setLonghelp(
+      "Value 1 stops heuristics immediately if the allowable gap has been reached. \
+Other values are for the feasibility pump - \
+2 says do exact number of passes given, \
+4 only applies if an initial cutoff has been given and says relax after 50 passes, \
+while 8 will adapt the cutoff rhs after the first solution if it looks as if the code is stalling.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("hot!StartMaxIts", "Maximum iterations on hot start",
+      0, COIN_INT_MAX, CBC_PARAM_INT_MAXHOTITS);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("idiot!Crash", "Whether to try idiot crash",
+      -1, COIN_INT_MAX, CLP_PARAM_INT_IDIOT);
+
+    p.setLonghelp(
+      "This is a type of 'crash' which works well on some homogeneous problems.\
+ It works best on problems with unit elements and rhs but will do something to any \
+ model.  It should only be used before the primal simplex algorithm.  It can be set to -1 when the code \
+ decides for itself whether to use it, 0 to switch off, or n > 0 to do n passes.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("import", "Import model from mps file",
+      CLP_PARAM_ACTION_IMPORT, 3);
+    p.setLonghelp(
+      "This will read an MPS format file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
+ files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'.  \
+If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("inc!rement", "A valid solution must be at least this \
+much better than last integer solution",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_INCREMENT);
+
+    p.setLonghelp(
+      "Whenever a solution is found the bound on the objective value for new solutions is set to the\
+      objective function of the found solution (in a minimization sense) plus this.  If it is not set then CBC will try and work one out, e.g. if \
+all objective coefficients are multiples of 0.01 and only integer variables have entries in \
+the objective function, then the increment can be set to 0.01.  Be careful if setting this to a negative value!");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("inf!easibilityWeight", "Each integer infeasibility is expected \
+to cost this much",
+      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
+    p.setLonghelp(
+      "A primitive way of deciding which node to explore next.  Satisfying each integer infeasibility is \
+expected to cost this much.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("initialS!olve", "Solve to continuous",
+      CLP_PARAM_ACTION_SOLVECONTINUOUS);
+
+    p.setLonghelp(
+      "This just solves the problem to continuous - without adding any cuts");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("integerT!olerance", "For a feasible solution \
+no integer variable may be more than this away from an integer value",
+      1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
+    p.setLonghelp(
+      "Beware of setting this smaller than the primal feasibility tolerance.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("keepN!ames", "Whether to keep names from import",
+      "on", CLP_PARAM_STR_KEEPNAMES);
+    p.append("off");
+    p.setLonghelp(
+      "It saves space to get rid of names so if you need to you can set this to off.  \
+This needs to be set before the import of model - so -keepnames off -import xxxxx.mps.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("KKT", "Whether to use KKT factorization in barrier",
+      "off", CLP_PARAM_STR_KKT, 7, 1);
+    p.append("on");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("knapsack!Cuts", "Whether to use Knapsack cuts",
+      "off", CBC_PARAM_STR_KNAPSACKCUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.append("forceandglobal");
+    p.setLonghelp(CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglKnapsackCover");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
+      "off", CBC_PARAM_STR_LAGOMORYCUTS);
+    p.append("endonlyroot");
+    p.append("endcleanroot");
+    p.append("root");
+    p.append("endonly");
+    p.append("endclean");
+    p.append("endboth");
+    p.append("onlyaswell");
+    p.append("cleanaswell");
+    p.append("bothaswell");
+    p.append("onlyinstead");
+    p.append("cleaninstead");
+    p.append("bothinstead");
+    p.append("onlyaswellroot");
+    p.append("cleanaswellroot");
+    p.append("bothaswellroot");
+    p.setLonghelp(
+      "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
+by Matteo Fischetti & Domenico Salvagnin.  This simplification \
+just uses original constraints while modifying objective using other cuts. \
+So you don't use messy constraints generated by Gomory etc. \
+A variant is to allow non messy cuts e.g. clique cuts. \
+So 'only' does this while 'clean' also allows integral valued cuts.  \
+'End' is recommended and waits until other cuts have finished before it \
+does a few passes. \
+The length options for gomory cuts are used.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
+      "off", CBC_PARAM_STR_LATWOMIRCUTS);
+
+    p.append("endonlyroot");
+    p.append("endcleanroot");
+    p.append("endbothroot");
+    p.append("endonly");
+    p.append("endclean");
+    p.append("endboth");
+    p.append("onlyaswell");
+    p.append("cleanaswell");
+    p.append("bothaswell");
+    p.append("onlyinstead");
+    p.append("cleaninstead");
+    p.append("bothinstead");
+    p.setLonghelp(
+      "This is a Lagrangean relaxation for TwoMir cuts.  See \
+  lagomoryCuts for description of options.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
+      "off", CBC_PARAM_STR_LANDPCUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.setLonghelp(
+      "These cuts may be expensive to compute. "
+      CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglLandP");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("local!TreeSearch", "Whether to use local tree search when a solution is found",
+      "off", CBC_PARAM_STR_LOCALTREE);
+    p.append("on");
+    p.setLonghelp(
+      "The heuristic is from Fischetti and Lodi and is not really a heuristic although it can be used as one \
+(with limited functionality).  It is not switched on when heuristics are switched on.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+#ifndef COIN_HAS_CBC
+    CbcOrClpParam p("log!Level", "Level of detail in Solver output",
+      -1, COIN_INT_MAX, CLP_PARAM_INT_SOLVERLOGLEVEL);
+    parameters.push_back(p);
+#else
+    CbcOrClpParam p("log!Level", "Level of detail in Coin branch and Cut output",
+      -63, 63, CLP_PARAM_INT_LOGLEVEL);
+    p.setIntValue(1);
+#endif
+    p.setLonghelp(
+      "If 0 then there should be no output in normal circumstances.  1 is probably the best\
+ value for most uses, while 2 and 3 give more information.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("max!imize", "Set optimization direction to maximize",
+      CLP_PARAM_ACTION_MAXIMIZE, 7);
+    p.setLonghelp(
+      "The default is minimize - use 'maximize' for maximization.\n\
+You can also use the parameters 'direction maximize'.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("maxF!actor", "Maximum number of iterations between \
+refactorizations",
+      1, COIN_INT_MAX, CLP_PARAM_INT_MAXFACTOR);
+    p.setLonghelp(
+      "If this is left at its default value of 200 then CLP will guess a\
+ value to use.  CLP may decide to re-factorize earlier for accuracy.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("maxIt!erations", "Maximum number of iterations before \
+stopping",
+      0, COIN_INT_MAX, CLP_PARAM_INT_MAXITERATION);
+    p.setLonghelp(
+      "This can be used for testing purposes.  The corresponding library call\n\
+      \tsetMaximumIterations(value)\n can be useful.  If the code stops on\
+ seconds or by an interrupt this will be treated as stopping on maximum iterations.  This is ignored in branchAndCut - use maxN!odes.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("maxN!odes", "Maximum number of nodes to do",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_MAXNODES);
+    p.setLonghelp(
+      "This is a repeatable way to limit search.  Normally using time is easier \
+but then the results may not be repeatable.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("maxSaved!Solutions", "Maximum number of solutions to save",
+      0, COIN_INT_MAX, CBC_PARAM_INT_MAXSAVEDSOLS);
+    p.setLonghelp(
+      "Number of solutions to save.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("maxSo!lutions", "Maximum number of feasible solutions to get",
+      1, COIN_INT_MAX, CBC_PARAM_INT_MAXSOLS);
+    p.setLonghelp(
+      "You may want to stop after (say) two solutions or an hour.  \
+This is checked every node in tree, so it is possible to get more solutions from heuristics.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("min!imize", "Set optimization direction to minimize",
+      CLP_PARAM_ACTION_MINIMIZE, 7);
+    p.setLonghelp(
+      "The default is minimize - use 'maximize' for maximization.\n\
+This should only be necessary if you have previously set maximization \
+You can also use the parameters 'direction minimize'.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("mipO!ptions", "Dubious options for mip",
+      0, COIN_INT_MAX, CBC_PARAM_INT_MIPOPTIONS, 0);
+    p.setIntValue(1057);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("more!MipOptions", "More dubious options for mip",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("more2!MipOptions", "More more dubious options for mip",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
+      "off", CBC_PARAM_STR_MIXEDCUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.setLonghelp(CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglMixedIntegerRounding2");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("mess!ages", "Controls if Clpnnnn is printed",
+      "off", CLP_PARAM_STR_MESSAGES);
+
+    p.append("on");
+    p.setLonghelp("The default behavior is to put out messages such as:\n\
+   Clp0005 2261  Objective 109.024 Primal infeas 944413 (758)\n\
+but this program turns this off to make it look more friendly.  It can be useful\
+ to turn them back on if you want to be able to 'grep' for particular messages or if\
+ you intend to override the behavior of a particular message.  This only affects Clp not Cbc.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("miplib", "Do some of miplib test set",
+      CBC_PARAM_ACTION_MIPLIB, 3, 1);
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("mips!tart", "reads an initial feasible solution from file",
+      CBC_PARAM_ACTION_MIPSTART);
+    p.setLonghelp("\
+The MIPStart allows one to enter an initial integer feasible solution \
+to CBC. Values of the main decision variables which are active (have \
+non-zero values) in this solution are specified in a text  file. The \
+text file format used is the same of the solutions saved by CBC, but \
+not all fields are required to be filled. First line may contain the \
+solution status and will be ignored, remaining lines contain column \
+indexes, names and values as in this example:\n\
+\n\
+Stopped on iterations - objective value 57597.00000000\n\
+      0  x(1,1,2,2)               1 \n\
+      1  x(3,1,3,2)               1 \n\
+      5  v(5,1)                   2 \n\
+      33 x(8,1,5,2)               1 \n\
+      ...\n\
+\n\
+Column indexes are also ignored since pre-processing can change them. \
+There is no need to include values for continuous or integer auxiliary \
+variables, since they can be computed based on main decision variables. \
+Starting CBC with an integer feasible solution can dramatically improve \
+its performance: several MIP heuristics (e.g. RINS) rely on having at \
+least one feasible solution available and can start immediately if the \
+user provides one. Feasibility Pump (FP) is a heuristic which tries to \
+overcome the problem of taking too long to find feasible solution (or \
+not finding at all), but it not always succeeds. If you provide one \
+starting solution you will probably save some time by disabling FP. \
+\n\n\
+Knowledge specific to your problem can be considered to write an \
+external module to quickly produce an initial feasible solution - some \
+alternatives are the implementation of simple greedy heuristics or the \
+solution (by CBC for example) of a simpler model created just to find \
+a feasible solution. \
+\n\n\
+Silly options added.  If filename ends .low then integers not mentioned \
+are set low - also .high, .lowcheap, .highcheap, .lowexpensive, .highexpensive \
+where .lowexpensive sets costed ones to make expensive others low. Also if \
+filename starts empty. then no file is read at all - just actions done. \
+\n\n\
+Question and suggestions regarding MIPStart can be directed to\n\
+haroldo.santos@gmail.com. ");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("moreS!pecialOptions", "Yet more dubious options for Simplex - see ClpSimplex.hpp",
+      0, COIN_INT_MAX, CLP_PARAM_INT_MORESPECIALOPTIONS, 0);
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("moreT!une", "Yet more dubious ideas for feasibility pump",
+      0, 100000000, CBC_PARAM_INT_FPUMPTUNE2, 0);
+
+    p.setLonghelp(
+      "Yet more ideas for Feasibility Pump \n\
+\t/100000 == 1 use box constraints and original obj in cleanup\n\
+\t/1000 == 1 Pump will run twice if no solution found\n\
+\t/1000 == 2 Pump will only run after root cuts if no solution found\n\
+\t/1000 >10 as above but even if solution found\n\
+\t/100 == 1,3.. exact 1.0 for objective values\n\
+\t/100 == 2,3.. allow more iterations per pass\n\
+\t n fix if value of variable same for last n iterations.");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
+      0, COIN_INT_MAX, CBC_PARAM_INT_MULTIPLEROOTS, 0);
+    p.setIntValue(0);
+    p.setLonghelp(
+      "Solve (in parallel, if enabled) the root phase this number of times, \
+      each with its own different seed, and collect all solutions and cuts generated. \
+      The actual format is aabbcc where aa is the number of extra passes; \
+      if bb is non zero, then it is number of threads to use (otherwise uses threads setting); \
+      and cc is the number of times to do root phase. \
+The solvers do not interact with each other.  However if extra passes are specified \
+then cuts are collected and used in later passes - so there is interaction there. \
+Some parts of this implementation have their origin in idea of \
+Andrea Lodi, Matteo Fischetti, Michele Monaci, Domenico Salvagnin, and Andrea Tramontani.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("naive!Heuristics", "Whether to try some stupid heuristic",
+      "off", CBC_PARAM_STR_NAIVE, 7, 1);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(
+      "This is naive heuristics which, e.g., fix all integers with costs to zero!. "
+      HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("netlib", "Solve entire netlib test set",
+      CLP_PARAM_ACTION_NETLIB_EITHER, 3, 1);
+    p.setLonghelp(
+      "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
+The user can set options before e.g. clp -presolve off -netlib");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("netlibB!arrier", "Solve entire netlib test set with barrier",
+      CLP_PARAM_ACTION_NETLIB_BARRIER, 3, 1);
+    p.setLonghelp(
+      "This exercises the unit test for clp and then solves the netlib test set using barrier.\
+The user can set options before e.g. clp -kkt on -netlib");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("netlibD!ual", "Solve entire netlib test set (dual)",
+      CLP_PARAM_ACTION_NETLIB_DUAL, 3, 1);
+
+    p.setLonghelp(
+      "This exercises the unit test for clp and then solves the netlib test set using dual.\
+The user can set options before e.g. clp -presolve off -netlib");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("netlibP!rimal", "Solve entire netlib test set (primal)",
+      CLP_PARAM_ACTION_NETLIB_PRIMAL, 3, 1);
+    p.setLonghelp(
+      "This exercises the unit test for clp and then solves the netlib test set using primal.\
+The user can set options before e.g. clp -presolve off -netlibp");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("netlibT!une", "Solve entire netlib test set with 'best' algorithm",
+      CLP_PARAM_ACTION_NETLIB_TUNE, 3, 1);
+    p.setLonghelp(
+      "This exercises the unit test for clp and then solves the netlib test set using whatever \
+works best.  I know this is cheating but it also stresses the code better by doing a \
+mixture of stuff.  The best algorithm was chosen on a Linux ThinkPad using native cholesky \
+with University of Florida ordering.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("network", "Tries to make network matrix",
+      CLP_PARAM_ACTION_NETWORK, 7, 0);
+    p.setLonghelp(
+      "Clp will go faster if the matrix can be converted to a network.  The matrix\
+ operations may be a bit faster with more efficient storage, but the main advantage\
+ comes from using a network factorization.  It will probably not be as fast as a \
+specialized network code.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("nextB!estSolution", "Prints next best saved solution to file",
+      CLP_PARAM_ACTION_NEXTBESTSOLUTION);
+
+    p.setLonghelp(
+      "To write best solution, just use solution.  This prints next best (if exists) \
+ and then deletes it. \
+ This will write a primitive solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("node!Strategy", "What strategy to use to select the next node from the branch and cut tree",
+      "hybrid", CBC_PARAM_STR_NODESTRATEGY);
+    p.append("fewest");
+    p.append("depth");
+    p.append("upfewest");
+    p.append("downfewest");
+    p.append("updepth");
+    p.append("downdepth");
+    p.setLonghelp(
+      "Normally before a feasible solution is found, CBC will choose a node with fewest infeasibilities. \
+  Alternatively, one may choose tree-depth as the criterion. This requires the minimal amount of memory, but may take a long time to find the best solution.\
+  Additionally, one may specify whether up or down branches must \
+be selected first (the up-down choice will carry on after a first solution has been bound). \
+The default choice 'hybrid' does breadth first on small depth nodes and then switches to 'fewest'.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("numberA!nalyze", "Number of analysis iterations",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_NUMBERANALYZE, 0);
+    p.setLonghelp(
+      "This says how many iterations to spend at root node analyzing problem. \
+This is a first try and will hopefully become more sophisticated.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("objective!Scale", "Scale factor to apply to objective",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE, 1);
+    p.setLonghelp(
+      "If the objective function has some very large values, you may wish to scale them\
+ internally by this amount.  It can also be set by autoscale.  It is applied after scaling.  You are unlikely to need this.");
+    p.setDoubleValue(1.0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_NTY
+  {
+    CbcOrClpParam p("Orbit!alBranching", "Whether to try orbital branching",
+      "off", CBC_PARAM_STR_ORBITAL);
+    p.append("on");
+    p.append("strong");
+    p.append("force");
+    p.append("simple");
+    p.append("fastish");
+    p.append("lightweight");
+    p.append("moreprinting");
+    p.append("cuts");
+    p.append("cutslight");
+    p.setLonghelp(
+      "This switches on Orbital branching. \
+Value 'on' just adds orbital, 'strong' tries extra fixing in strong branching. \
+'cuts' just adds global cuts to break symmetry. \
+'fastish' only computes symmetry at root. \
+'lightweight' is as on where computation seems cheap");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("PrepN!ames", "If column names will be kept in pre-processed model",
+      "off", CBC_PARAM_STR_PREPROCNAMES);
+    p.append("on");
+    p.setLonghelp(
+      "Normally the preprocessed model has column names replaced by new names C0000...\
+Setting this option to on keeps original names in variables which still exist in the preprocessed problem");
+    parameters.push_back(p);
+  }
+
+  {
+    CbcOrClpParam p("outDup!licates", "takes duplicate rows etc out of integer model",
+      CLP_PARAM_ACTION_OUTDUPROWS, 7, 0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("output!Format", "Which output format to use",
+      1, 6, CLP_PARAM_INT_OUTPUTFORMAT);
+    p.setLonghelp(
+      "Normally export will be done using normal representation for numbers and two values\
+ per line.  You may want to do just one per line (for grep or suchlike) and you may wish\
+ to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\
+ otherwise odd values gives one value per line, even two.  Values 1,2 give normal format, 3,4\
+ gives greater precision, while 5,6 give IEEE values.  When used for exporting a basis 1 does not save \
+values, 2 saves values, 3 with greater accuracy and 4 in IEEE.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("para!metrics", "Import data from file and do parametrics",
+      CLP_PARAM_ACTION_PARAMETRICS, 3);
+    p.setLonghelp(
+      "This will read a file with parametric data from the given file name \
+and then do parametrics.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  This can not read from compressed files. \
+File is in modified csv format - a line ROWS will be followed by rows data \
+while a line COLUMNS will be followed by column data.  The last line \
+should be ENDATA. The ROWS line must exist and is in the format \
+ROWS, inital theta, final theta, interval theta, n where n is 0 to get \
+CLPI0062 message at interval or at each change of theta \
+and 1 to get CLPI0063 message at each iteration.  If interval theta is 0.0 \
+or >= final theta then no interval reporting.  n may be missed out when it is \
+taken as 0.  If there is Row data then \
+there is a headings line with allowed headings - name, number, \
+lower(rhs change), upper(rhs change), rhs(change).  Either the lower and upper \
+fields should be given or the rhs field. \
+The optional COLUMNS line is followed by a headings line with allowed \
+headings - name, number, objective(change), lower(change), upper(change). \
+ Exactly one of name and number must be given for either section and \
+missing ones have value 0.0.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("passC!uts", "Number of rounds that cut generators are applied in the root node",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASS);
+
+    p.setIntValue(20);
+    p.setLonghelp(
+      "The default is to do 100 passes if the problem has less than 500 columns, 100 passes (but \
+stop if the drop in the objective function value is small) if the problem has less than 5000 columns, and 20 passes otherwise. \
+A negative value -n means that n passes are also applied if the objective does not drop.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("passF!easibilityPump", "How many passes to do in the Feasibility Pump heuristic",
+      0, 10000, CBC_PARAM_INT_FPUMPITS);
+    p.setIntValue(20);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("passP!resolve", "How many passes in presolve",
+      -200, 100, CLP_PARAM_INT_PRESOLVEPASS, 1);
+    p.setLonghelp(
+      "Normally Presolve does 10 passes but you may want to do less to make it\
+ more lightweight or do more if improvements are still being made.  As Presolve will return\
+ if nothing is being taken out, you should not normally need to use this fine tuning.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("passT!reeCuts", "Number of rounds that cut generators are applied in the tree",
+      -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_CUTPASSINTREE);
+    p.setIntValue(1);
+    p.setLonghelp("The default is to do one pass. A negative value -n means that n passes are also applied if the objective does not drop.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("pertV!alue", "Method of perturbation",
+      -5000, 102, CLP_PARAM_INT_PERTVALUE, 1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("perturb!ation", "Whether to perturb the problem",
+      "on", CLP_PARAM_STR_PERTURBATION);
+    p.append("off");
+    p.setLonghelp(
+      "Perturbation helps to stop cycling, but CLP uses other measures for this.\
+  However, large problems and especially ones with unit elements and unit right hand sides or costs\
+ benefit from perturbation.  Normally CLP tries to be intelligent, but one can switch this off.");
+  // The Clp library has this off by default.  This program has it on by default.
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("PFI", "Whether to use Product Form of Inverse in simplex",
+      "off", CLP_PARAM_STR_PFI, 7, 0);
+    p.append("on");
+    p.setLonghelp(
+      "By default clp uses Forrest-Tomlin L-U update.  If you are masochistic you can switch it off.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("pivotAndC!omplement", "Whether to try Pivot and Complement heuristic",
+      "off", CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("pivotAndF!ix", "Whether to try Pivot and Fix heuristic",
+      "off", CBC_PARAM_STR_PIVOTANDFIX);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("plus!Minus", "Tries to make +- 1 matrix",
+      CLP_PARAM_ACTION_PLUSMINUS, 7, 0);
+    p.setLonghelp(
+      "Clp will go slightly faster if the matrix can be converted so that the elements are\
+ not stored and are known to be unit.  The main advantage is memory use.  Clp may automatically\
+ see if it can convert the problem so you should not need to use this.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("pO!ptions", "Dubious print options",
+      0, COIN_INT_MAX, CLP_PARAM_INT_PRINTOPTIONS, 1);
+    p.setIntValue(0);
+    p.setLonghelp(
+      "If this is > 0 then presolve will give more information and branch and cut will give statistics");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("preO!pt", "Presolve options",
+      0, COIN_INT_MAX, CLP_PARAM_INT_PRESOLVEOPTIONS, 0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("presolve", "Whether to presolve problem",
+      "on", CLP_PARAM_STR_PRESOLVE);
+    p.append("off");
+    p.append("more");
+    p.append("file");
+    p.setLonghelp("Presolve analyzes the model to find such things as redundant equations, equations\
+ which fix some variables, equations which can be transformed into bounds, etc.  For the\
+ initial solve of any problem this is worth doing unless one knows that it will have no effect.  \
+Option 'on' will normally do 5 passes, while using 'more' will do 10.  If the problem is very large one can \
+let CLP write the original problem to file by using 'file'.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("preprocess", "Whether to use integer preprocessing",
+      "off", CBC_PARAM_STR_PREPROCESS);
+
+    p.append("on");
+    p.append("save");
+    p.append("equal");
+    p.append("sos");
+    p.append("trysos");
+    p.append("equalall");
+    p.append("strategy");
+    p.append("aggregate");
+    p.append("forcesos");
+    p.append("stop!aftersaving");
+    p.setLonghelp(
+      "This tries to reduce size of model in a similar way to presolve and \
+it also tries to strengthen the model - this can be very useful and is worth trying. \
+ Value 'save' saves the presolved problem to a file presolved.mps.\
+ Value 'equal' will turn inequality-cliques into equalities.\
+ Value 'sos' lets CBC search for rows with upper bound 1 and where all nonzero coefficients are 1 and creates special ordered sets if the sets are not overlapping and all integer variables (except for at most one) are in the sets.\
+ Value 'trysos' is same as 'sos', but allows any number of integer variables outside of sets.\
+ Value 'equalall' lets CBC turn all valid inequalities into equalities by adding integer slack variables."); // Value 'strategy' is as on but uses CbcStrategy.
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("preT!olerance", "Tolerance to use in presolve",
+      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRESOLVETOLERANCE);
+    p.setLonghelp(
+      "One may want to increase this tolerance if presolve says the problem is \
+infeasible and one has awkward numbers and is sure that the problem is really feasible.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("primalP!ivot", "Primal pivot choice algorithm",
+      "auto!matic", CLP_PARAM_STR_PRIMALPIVOT, 7, 1);
+
+    p.append("exa!ct");
+    p.append("dant!zig");
+    p.append("part!ial");
+    p.append("steep!est");
+    p.append("change");
+    p.append("sprint");
+    p.append("PEsteep!est");
+    p.append("PEdantzig");
+    p.setLonghelp(
+      "The Dantzig method is simple but its use is deprecated.  Exact devex is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while 'change' initially does 'dantzig' until the factorization\
+ becomes denser.  This is still a work in progress.\
+ The PE variants add the Positive Edge criterion.\
+ This selects incoming variables to try to avoid degenerate moves. \
+ See also Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR's CLP;\
+ Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("primalS!implex", "Do primal simplex algorithm",
+      CLP_PARAM_ACTION_PRIMALSIMPLEX);
+
+    p.setLonghelp(
+      "This command solves the continuous relaxation of the current model using the primal algorithm.\
+  The default is to use exact devex.\
+ The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by column selection  method, infeasibility weight and dual and primal tolerances.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("primalT!olerance", "For a feasible solution \
+no primal infeasibility, i.e., constraint violation, may exceed this value",
+      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALTOLERANCE);
+    p.setLonghelp(
+      "Normally the default tolerance is fine, but one may want to increase it a\
+ bit if the primal simplex algorithm seems to be having a hard time.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("primalW!eight", "Initially algorithm acts as if it \
+costs this much to be infeasible",
+      1.0e-20, COIN_DBL_MAX, CLP_PARAM_DBL_PRIMALWEIGHT);
+    p.setLonghelp(
+      "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal.  So Clp is minimizing this weight times\
+ the sum of primal infeasibilities plus the true objective function (in minimization sense).\
+  Too high a value may mean more iterations, while too low a value means\
+ the algorithm may iterate into the wrong directory for long and then has to increase the weight in order to get feasible."); // OSL had a heuristic to adjust bounds, maybe we need that here.
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("psi", "Two-dimension pricing factor for Positive Edge criterion",
+      -1.1, 1.1, CLP_PARAM_DBL_PSI);
+
+    p.setDoubleValue(-0.5);
+    p.setLonghelp(
+      "The Positive Edge criterion has been added to \
+select incoming variables to try and avoid degenerate moves. \
+Variables not in the promising set have their infeasibility weight multiplied by psi, \
+so 0.01 would mean that if there were any promising variables, then they would always be chosen, \
+while 1.0 effectively switches the algorithm off. \
+There are two ways of switching this feature on.  One way is to set psi to a positive value and then \
+the Positive Edge criterion will be used for both primal and dual simplex.  The other way is to select PEsteepest \
+in dualpivot choice (for example), then the absolute value of psi is used. \
+Code donated by Jeremy Omer.  See \
+Towhidi, M., Desrosiers, J., Soumis, F., The positive edge criterion within COIN-OR's CLP; \
+Omer, J., Towhidi, M., Soumis, F., The positive edge pricing rule for the dual simplex.");  // Until this settles down it is only implemented in CLP.
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("printi!ngOptions", "Print options",
+      "normal", CLP_PARAM_STR_INTPRINT, 3);
+    p.append("integer");
+    p.append("special");
+    p.append("rows");
+    p.append("all");
+    p.append("csv");
+    p.append("bound!ranging");
+    p.append("rhs!ranging");
+    p.append("objective!ranging");
+    p.append("stats");
+    p.append("boundsint");
+    p.append("boundsall");
+    p.append("fixint");
+    p.append("fixall");
+    p.setLonghelp(
+      "This changes the amount and format of printing a solution:\nnormal - nonzero column variables \n\
+integer - nonzero integer column variables\n\
+special - in format suitable for OsiRowCutDebugger\n\
+rows - nonzero column variables and row activities\n\
+all - all column variables and row activities.\n\
+\nFor non-integer problems 'integer' and 'special' act like 'normal'.  \
+Also see printMask for controlling output.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("printM!ask", "Control printing of solution on a  mask",
+      CLP_PARAM_ACTION_PRINTMASK, 3);
+
+    p.setLonghelp(
+      "If set then only those names which match mask are printed in a solution. \
+'?' matches any character and '*' matches any set of characters. \
+ The default is '' i.e. unset so all variables are printed. \
+This is only active if model has names.");
+    parameters.push_back(p);
+  }
+
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("prio!rityIn", "Import priorities etc from file",
+      CBC_PARAM_ACTION_PRIORITYIN, 3);
+    p.setLonghelp(
+      "This will read a file with priorities from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to '', i.e. it must be set.  This can not read from compressed files. \
+File is in csv format with allowed headings - name, number, priority, direction, up, down, solution.  Exactly one of\
+ name and number must be given.");
+    parameters.push_back(p);
+  }
+
+  {
+    CbcOrClpParam p("probing!Cuts", "Whether to use Probing cuts",
+      "off", CBC_PARAM_STR_PROBINGCUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.append("forceonglobal");
+    p.append("forceOnBut");
+    p.append("forceOnStrong");
+    p.append("forceOnButStrong");
+    p.append("strongRoot");
+    p.setLonghelp(CUTS_LONGHELP
+      " Value 'forceOnBut' turns on probing and forces CBC to do probing at every node, but does only probing, not strengthening etc. \
+    Value 'strong' forces CBC to strongly do probing at every node, that is, also when CBC would usually turn it off because it hasn't found something. \
+    Value 'forceonbutstrong' is like 'forceonstrong', but does only probing (column fixing) and turns off row strengthening, so the matrix will not change inside the branch and bound. \
+    Reference: https://github.com/coin-or/Cgl/wiki/CglProbing");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("proximity!Search", "Whether to do proximity search heuristic",
+      "off", CBC_PARAM_STR_PROXIMITY);
+
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("10");
+    p.append("100");
+    p.append("300");
+    // but allow numbers after this (returning 1)
+    p.setFakeKeyWord(1);
+    p.setLonghelp(
+      "This heuristic looks for a solution close to the incumbent solution (Fischetti and Monaci, 2012). \
+The idea is to define a sub-MIP without additional constraints but with a modified objective function intended to attract the search \
+in the proximity of the incumbent. \
+The approach works well for 0-1 MIPs whose solution landscape is not too irregular (meaning the there is reasonable probability of \
+finding an improved solution by flipping a small number of binary variables), in particular when it is applied to the first heuristic solutions \
+found at the root node. "
+      HEURISTICS_LONGHELP); // Can also set different maxNode settings by plusnnnn (and are 'on'(on==30)).
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("pumpC!utoff", "Fake cutoff for use in feasibility pump",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKECUTOFF);
+    p.setDoubleValue(0.0);
+    p.setLonghelp(
+      "A value of 0.0 means off. Otherwise, add a constraint forcing objective below this value\
+ in feasibility pump");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("pumpI!ncrement", "Fake increment for use in feasibility pump",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKEINCREMENT, 1);
+    p.setDoubleValue(0.0);
+    p.setLonghelp(
+      "A value of 0.0 means off. Otherwise use as absolute increment to cutoff \
+when solution found in feasibility pump");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("pumpT!une", "Dubious ideas for feasibility pump",
+      0, 100000000, CBC_PARAM_INT_FPUMPTUNE);
+    p.setIntValue(1003);
+    p.setLonghelp(
+      "This fine tunes Feasibility Pump \n\
+\t>=10000000 use as objective weight switch\n\
+\t>=1000000 use as accumulate switch\n\
+\t>=1000 use index+1 as number of large loops\n\
+\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR fakeCutoff if set\n\
+\t%100 == 10,20 affects how each solve is done\n\
+\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds. \
+If accumulate is on then after a major pass, variables which have not moved \
+are fixed and a small branch and bound is tried.");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("quit", "Stops clp execution",
+      CLP_PARAM_ACTION_EXIT);
+    p.setLonghelp(
+      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
+
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("randomC!bcSeed", "Random seed for Cbc",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_RANDOMSEED);
+
+    p.setLonghelp(
+      "Allows initialization of the random seed for pseudo-random numbers used in heuristics such as the Feasibility Pump to decide whether to round up or down. "
+      "The special value of 0 lets Cbc use the time of the day for the initial seed.");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("randomi!zedRounding", "Whether to try randomized rounding heuristic",
+      "off", CBC_PARAM_STR_RANDROUND);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("randomS!eed", "Random seed for Clp",
+      0, COIN_INT_MAX, CLP_PARAM_INT_RANDOMSEED);
+
+    p.setLonghelp(
+      "Initialization of the random seed for pseudo-random numbers used to break ties in degenerate problems. "
+      "This may yield a different continuous optimum and, in the context of Cbc, different cuts and heuristic solutions. "
+      "The special value of 0 lets CLP use the time of the day for the initial seed.");
+    p.setIntValue(1234567);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("ratio!Gap", "Stop when gap between best possible and \
+best known is less than this fraction of larger of two",
+      0.0, COIN_DBL_MAX, CBC_PARAM_DBL_GAPRATIO);
+    p.setDoubleValue(0.0);
+    p.setLonghelp(
+      "If the gap between the best known solution and the best possible solution is less than this fraction \
+of the objective value at the root node then the search will terminate.  See 'allowableGap' for a \
+way of using absolute value rather than fraction.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("restoreS!olution", "reads solution from file",
+      CLP_PARAM_ACTION_RESTORESOL);
+
+    p.setLonghelp(
+      "This will read a binary solution file from the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'solution.file'.  This reads in a file from saveSolution");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("readSt!ored", "Import stored cuts from file",
+      CLP_PARAM_ACTION_STOREDFILE, 3, 0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_OBJSCALE2, 0);
+    p.setLonghelp("You can set this to -1.0 to test maximization or other to stress code");
+    p.setDoubleValue(1.0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("reallyS!cale", "Scales model in place",
+      CLP_PARAM_ACTION_REALLY_SCALE, 7, 0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("reduce!AndSplitCuts", "Whether to use Reduce-and-Split cuts",
+      "off", CBC_PARAM_STR_REDSPLITCUTS);
+
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.setLonghelp(
+      "These cuts may be expensive to generate. "
+      CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglRedSplit");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
+      "off", CBC_PARAM_STR_REDSPLIT2CUTS);
+    p.append("on");
+    p.append("root");
+    p.append("longOn");
+    p.append("longRoot");
+    p.setLonghelp("This switches on reduce and split  cuts (either at root or in entire tree). \
+This version is by Giacomo Nannicini based on Francois Margot's version. \
+Standard setting only uses rows in tableau <= 256, long uses all. \
+These cuts may be expensive to generate. \
+See option cuts for more information on the possible values.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("residual!CapacityCuts", "Whether to use Residual Capacity cuts",
+      "off", CBC_PARAM_STR_RESIDCUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.setLonghelp(CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglResidualCapacity");
+
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("restore!Model", "Restore model from binary file",
+      CLP_PARAM_ACTION_RESTORE, 7, 1);
+    p.setLonghelp(
+      "This reads data save by saveModel from the given file.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.prob'.");
+
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("reverse", "Reverses sign of objective",
+      CLP_PARAM_ACTION_REVERSE, 7, 0);
+    p.setLonghelp(
+      "Useful for testing if maximization works correctly");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("rhs!Scale", "Scale factor to apply to rhs and bounds",
+      -COIN_DBL_MAX, COIN_DBL_MAX, CLP_PARAM_DBL_RHSSCALE, 0);
+    p.setLonghelp(
+      "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
+ internally by this amount.  It can also be set by autoscale.  This should not be needed.");
+    p.setDoubleValue(1.0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("Rens", "Whether to try Relaxation Enforced Neighborhood Search",
+      "off", CBC_PARAM_STR_RENS);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("200");
+    p.append("1000");
+    p.append("10000");
+    p.append("dj");
+    p.append("djbefore");
+    p.append("usesolution");
+    p.setLonghelp(HEURISTICS_LONGHELP
+      " Value 'on' just does 50 nodes. 200, 1000, and 10000 does that many nodes.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("Rins", "Whether to try Relaxed Induced Neighborhood Search",
+      "off", CBC_PARAM_STR_RINS);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("often");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("round!ingHeuristic", "Whether to use simple (but effective) Rounding heuristic",
+      "off", CBC_PARAM_STR_ROUNDING);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("saveM!odel", "Save model to binary file",
+      CLP_PARAM_ACTION_SAVE, 7, 1);
+    p.setLonghelp(
+      "This will save the problem to the given file name for future use\
+ by restoreModel.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'default.prob'.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("saveS!olution", "saves solution to file",
+      CLP_PARAM_ACTION_SAVESOL);
+
+    p.setLonghelp(
+      "This will write a binary solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'solution.file'.  To read the file use fread(int) twice to pick up number of rows \
+and columns, then fread(double) to pick up objective value, then pick up row activities, row duals, column \
+activities and reduced costs - see bottom of CbcOrClpParam.cpp for code that reads or writes file. \
+If name contains '_fix_read_' then does not write but reads and will fix all variables");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("scal!ing", "Whether to scale problem",
+      "off", CLP_PARAM_STR_SCALING);
+    p.append("equi!librium");
+    p.append("geo!metric");
+    p.append("auto!matic");
+    p.append("dynamic");
+    p.append("rows!only");
+    p.setLonghelp(
+      "Scaling can help in solving problems which might otherwise fail because of lack of\
+ accuracy.  It can also reduce the number of iterations.  It is not applied if the range\
+ of elements is small.  When the solution is evaluated in the unscaled problem, it is possible that small primal and/or\
+ dual infeasibilities occur. "
+ "Option 'equilibrium' uses the largest element for scaling. "
+ "Option 'geometric' uses the squareroot of the product of largest and smallest element. "
+ "Option 'auto' let CLP choose a method that gives the best ratio of the largest element to the smallest one.");
+    p.setCurrentOption(3); // say auto
+    parameters.push_back(p);
+  }
+#ifndef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("sec!onds", "Maximum seconds",
+      -1.0, COIN_DBL_MAX, CLP_PARAM_DBL_TIMELIMIT);
+
+    p.setLonghelp("After this many seconds clp will act as if maximum iterations had been reached \
+(if value >=0).");
+    parameters.push_back(p);
+  }
+#else
+  {
+    CbcOrClpParam p("sec!onds", "maximum seconds",
+      -1.0, COIN_DBL_MAX, CBC_PARAM_DBL_TIMELIMIT_BAB);
+    p.setLonghelp(
+      "After this many seconds coin solver will act as if maximum nodes had been reached.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("sleep", "for debug",
+      CLP_PARAM_ACTION_DUMMY, 7, 0);
+
+    p.setLonghelp(
+      "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("slow!cutpasses", "Maximum number of rounds for slower cut generators",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
+    p.setLonghelp(
+      "Some cut generators are fairly slow - this limits the number of times they are tried.\
+      The cut generators identified as 'may be slow' at present are Lift and project cuts and both versions of Reduce and Split cuts.");
+    p.setIntValue(10);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("slp!Value", "Number of slp passes before primal",
+      -50000, 50000, CLP_PARAM_INT_SLPVALUE, 1);
+    p.setLonghelp(
+      "If you are solving a quadratic problem using primal then it may be helpful to do some \
+sequential Lps to get a good approximate solution.");
+    parameters.push_back(p);
+  }
+#if CLP_MULTIPLE_FACTORIZATIONS > 0
+  {
+    CbcOrClpParam p("small!Factorization", "Threshold for using small factorization",
+      -1, 10000, CBC_PARAM_INT_SMALLFACT, 1);
+    p.setLonghelp(
+      "If processed problem <= this use small factorization");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+#endif
+#endif
+  {
+    CbcOrClpParam p("solu!tion", "Prints solution to file",
+      CLP_PARAM_ACTION_SOLUTION);
+    p.setLonghelp(
+      "This will write a primitive solution file to the given file name.  It will use the default\
+ directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
+ is initialized to 'stdout'.  The amount of output can be varied using printi!ngOptions or printMask.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CLP
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("solv!e", "Solve problem",
+      CBC_PARAM_ACTION_BAB);
+         p.setLonghelp(
+          "If there are no integer variables then this just solves LP.  If there are integer variables \
+this does branch and cut." );
+         parameters.push_back( p );
+  }
+  {
+    CbcOrClpParam p("sosO!ptions", "Whether to use SOS from AMPL",  "off", CBC_PARAM_STR_SOS);
+    p.append("on");
+    p.setCurrentOption("on");
+         p.setLonghelp(
+          "Normally if AMPL says there are SOS variables they should be used, but sometime sthey should\
+ be turned off - this does so." );
+         parameters.push_back( p );
+  }
+  {
+    CbcOrClpParam p("slog!Level", "Level of detail in (LP) Solver output", -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
+    p.setLonghelp(
+      "If 0 then there should be no output in normal circumstances.  1 is probably the best\
+ value for most uses, while 2 and 3 give more information.  This parameter is only used inside MIP - for Clp use 'log'");
+    parameters.push_back(p);
+  }
+  {
+     // Due to James Howey
+     CbcOrClpParam p("sosP!rioritize", "How to deal with SOS priorities",
+       "off", CBC_PARAM_STR_SOSPRIORITIZE);
+     p.append("high");
+     p.append("low");
+     p.append("orderhigh");
+     p.append("orderlow");
+     p.setLonghelp(
+       "This sets priorities for SOS.  Values 'high' and 'low' just set a priority \
+    relative to the for integer variables.  Value 'orderhigh' gives first highest priority to the first SOS and integer variables \
+    a low priority.  Value 'orderlow' gives integer variables a high priority then SOS in order.");
+    parameters.push_back(p);
+  }
+#else
+  // allow solve as synonym for possible dual
+  {
+    CbcOrClpParam p("solv!e", "Solve problem using dual simplex (probably)",
+      CLP_PARAM_ACTION_EITHERSIMPLEX);
+    p.setLonghelp(
+      "Just so can use solve for clp as well as in cbc");
+    parameters.push_back(p);
+  }
+#endif
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("spars!eFactor", "Whether factorization treated as sparse",
+      "on", CLP_PARAM_STR_SPARSEFACTOR, 7, 0);
+    p.append("off");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("special!Options", "Dubious options for Simplex - see ClpSimplex.hpp",
+      0, COIN_INT_MAX, CLP_PARAM_INT_SPECIALOPTIONS, 0);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("sprint!Crash", "Whether to try sprint crash",
+      -1, COIN_INT_MAX, CLP_PARAM_INT_SPRINT);
+    p.setLonghelp(
+      "For long and thin problems this method may solve a series of small problems\
+ created by taking a subset of the columns.  The idea as 'Sprint' was introduced by J. Forrest after\
+ an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
+  CPLEX calls it 'sifting'.  -1 lets CLP automatically choose the number of passes, 0 is off, n is number of passes");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("stat!istics", "Print some statistics",
+      CLP_PARAM_ACTION_STATISTICS);
+    p.setLonghelp(
+      "This command prints some statistics for the current model.\
+ If log level >1 then more is printed.\
+ These are for presolved model if presolve on (and unscaled).");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("stop", "Stops clp execution",
+      CLP_PARAM_ACTION_EXIT);
+    p.setLonghelp(
+      "This stops the execution of Clp, end, exit, quit and stop are synonyms");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("strat!egy", "Switches on groups of features",
+      0, 2, CBC_PARAM_INT_STRATEGY);
+    p.setLonghelp(
+      "This turns on newer features. \
+Use 0 for easy problems, 1 is default, 2 is aggressive. \
+1 uses Gomory cuts with a tolerance of 0.01 at the root node, \
+does a possible restart after 100 nodes if many variables could be fixed, \
+activates a diving and RINS heuristic, and makes the feasibility pump \
+more aggressive."); // This does not apply to unit tests (where 'experiment' may have similar effects
+    p.setIntValue(1);
+    parameters.push_back(p);
+  }
+#ifdef CBC_KEEP_DEPRECATED
+  {
+    CbcOrClpParam p("strengthen", "Create strengthened problem",
+      CBC_PARAM_ACTION_STRENGTHEN, 3);
+    p.setLonghelp(
+      "This creates a new problem by applying the root node cuts.  All tight constraints \
+will be in resulting problem");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("strong!Branching", "Number of variables to look at in strong branching",
+      0, COIN_INT_MAX, CBC_PARAM_INT_STRONGBRANCHING);
+    p.setIntValue(20);
+    p.setLonghelp(
+      "In order to decide which variable to branch on, the code will choose up to this number \
+of unsatisfied variables to try minimal up and down branches on.  Then the most effective one is chosen. \
+If a variable is branched on many times then the previous average up and down costs may be used - \
+see also option trustPseudoCosts.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("subs!titution", "How long a column to substitute for in presolve",
+      0, 10000, CLP_PARAM_INT_SUBSTITUTION, 0);
+    p.setLonghelp(
+      "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
+ coefficients in a row.  If you increase this, the number of rows may decrease but the number of \
+ coefficients may increase.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("testO!si", "Test OsiObject stuff",
+      -1, COIN_INT_MAX, CBC_PARAM_INT_TESTOSI, 0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef CBC_THREAD
+  {
+    CbcOrClpParam p("thread!s", "Number of threads to try and use",
+      -100, 100000, CBC_PARAM_INT_THREADS, 1);
+    p.setIntValue(0);
+    p.setLonghelp(
+      "To use multiple threads, set threads to number wanted.  It may be better \
+to use one or two more than number of cpus available.  If 100+n then n threads and \
+search is repeatable (maybe be somewhat slower), \
+if 200+n use threads for root cuts, 400+n threads used in sub-trees.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("tighten!Factor", "Tighten bounds using this times largest \
+activity at continuous solution",
+      1.0e-3, COIN_DBL_MAX, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
+    p.setLonghelp(
+      "This sleazy trick can help on some problems.");
+    parameters.push_back(p);
+  }
+
+#endif
+#ifdef COIN_HAS_CLP
+  {
+    CbcOrClpParam p("tightLP", "Poor person's preSolve for now",
+      CLP_PARAM_ACTION_TIGHTEN, 7, 0);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("timeM!ode", "Whether to use CPU or elapsed time",
+      "cpu", CLP_PARAM_STR_TIME_MODE);
+    p.append("elapsed");
+    p.setLonghelp(
+      "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
+(On Windows, elapsed time is always used).");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
+      -3, COIN_INT_MAX, CBC_PARAM_INT_NUMBERBEFORE);
+    p.setLonghelp(
+      "Using strong branching computes pseudo-costs.  This parameter determines after how many branches for a variable we just \
+trust the pseudo costs and do not do any more strong branching.");
+    p.setIntValue(10);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("tune!PreProcess", "Dubious tuning parameters for preprocessing",
+      0, COIN_INT_MAX, CLP_PARAM_INT_PROCESSTUNE, 1);
+    p.setLonghelp(
+      "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
+If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) \n \
+cccc is bit set \n 0 - 1 Heavy probing \n 1 - 2 Make variables integer if possible (if obj value)\n \
+2 - 4 As above but even if zero objective value\n \
+7 - 128 Try and create cliques\n 8 - 256 If all +1 try hard for dominated rows\n \
+10 - 1024 Use a larger feasibility tolerance in presolve\n \
+11 - 2048 Try probing before creating cliques\n \
+12 - 4096 Switch off duplicate column checking for integers \n \n \
+     Now aa 99 has special meaning i.e. just one simple presolve.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("two!MirCuts", "Whether to use Two phase Mixed Integer Rounding cuts",
+      "off", CBC_PARAM_STR_TWOMIRCUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.append("forceandglobal");
+    p.append("forceLongOn");
+    p.setLonghelp(CUTS_LONGHELP
+      " Reference: https://github.com/coin-or/Cgl/wiki/CglTwomir");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("unitTest", "Do unit test",
+      CLP_PARAM_ACTION_UNITTEST, 3, 1);
+    p.setLonghelp(
+      "This exercises the unit test for clp");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("userClp", "Hand coded Clp stuff",
+      CLP_PARAM_ACTION_USERCLP, 0, 0);
+    p.setLonghelp(
+      "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
+Look for USERCLP in main driver and modify sample code.");
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("userCbc", "Hand coded Cbc stuff",
+      CBC_PARAM_ACTION_USERCBC, 0, 0);
+    p.setLonghelp(
+      "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
+Look for USERCBC in main driver and modify sample code. \
+It is possible you can get same effect by using example driver4.cpp.");
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_AVX2
+  {
+    CbcOrClpParam p("vector!Mode", "Try and use vector instructions",
+      0, 11, CLP_PARAM_INT_VECTOR_MODE);
+    p.setLonghelp(
+      "At present only for Intel architectures - but could be extended.  \
+Uses avx2 or avx512 instructions. Uses different storage for matrix - can be \
+of benefit without instruction set on some problems.  \
+Being lazy I have used 10 to switch on a pool matrix (11 may come later)");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#endif
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("Vnd!VariableNeighborhoodSearch", "Whether to try Variable Neighborhood Search",
+      "off", CBC_PARAM_STR_VND);
+    p.append("on");
+    p.append("both");
+    p.append("before");
+    p.append("intree");
+    p.setLonghelp(HEURISTICS_LONGHELP);
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("vector", "Whether to use vector? Form of matrix in simplex",
+      "off", CLP_PARAM_STR_VECTOR, 7, 0);
+    p.append("on");
+    p.setLonghelp(
+      "If this is on ClpPackedMatrix uses extra column copy in odd format.");
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("verbose", "Switches on longer help on single ?",
+      0, 31, CLP_PARAM_INT_VERBOSE, 0);
+    p.setLonghelp(
+      "Set to 1 to get short help with ? list, 2 to get long help, 3 for both.  (add 4 to just get ampl ones).");
+    p.setIntValue(0);
+    parameters.push_back(p);
+  }
+#ifdef COIN_HAS_CBC
+  {
+    CbcOrClpParam p("vub!heuristic", "Type of VUB heuristic",
+      -2, 20, CBC_PARAM_INT_VUBTRY, 0);
+    p.setLonghelp(
+      "This heuristic tries and fix some integer variables.");
+    p.setIntValue(-1);
+    parameters.push_back(p);
+  }
+  {
+    CbcOrClpParam p("zero!HalfCuts", "Whether to use zero half cuts",
+      "off", CBC_PARAM_STR_ZEROHALFCUTS);
+    p.append("on");
+    p.append("root");
+    p.append("ifmove");
+    p.append("forceOn");
+    p.append("onglobal");
+    p.setLonghelp(CUTS_LONGHELP
+      " This implementation was written by Alberto Caprara.");
+    parameters.push_back(p);
+  }
+#endif
+  {
+    CbcOrClpParam p("zeroT!olerance", "Kill all coefficients \
+whose absolute value is less than this value",
+      1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
+    p.setLonghelp(
+      "This applies to reading mps files (and also lp files \
+if KILL_ZERO_READLP defined)");
+    p.setDoubleValue(1.0e-20);
+    parameters.push_back(p);
+  }
+}
+// Given a parameter type - returns its number in list
+int whichParam(const CbcOrClpParameterType &name,
+  const std::vector< CbcOrClpParam > &parameters)
+{
+  for (int i = 0; i < (int)parameters.size(); i++) {
+    if (parameters[i].type() == name)
+      return i;
+  }
+  return std::numeric_limits< int >::max(); // should not arrive here
+}
+#ifdef COIN_HAS_CLP
+/* Restore a solution from file.
+   mode 0 normal, 1 swap rows and columns and primal and dual
+   if 2 set then also change signs
+*/
+void restoreSolution(ClpSimplex *lpSolver, std::string fileName, int mode)
+{
+  FILE *fp = fopen(fileName.c_str(), "rb");
+  if (fp) {
+    int numberRows = lpSolver->numberRows();
+    int numberColumns = lpSolver->numberColumns();
+    int numberRowsFile;
+    int numberColumnsFile;
+    double objectiveValue;
+    size_t nRead;
+    nRead = fread(&numberRowsFile, sizeof(int), 1, fp);
+    if (nRead != 1)
+      throw("Error in fread");
+    nRead = fread(&numberColumnsFile, sizeof(int), 1, fp);
+    if (nRead != 1)
+      throw("Error in fread");
+    nRead = fread(&objectiveValue, sizeof(double), 1, fp);
+    if (nRead != 1)
+      throw("Error in fread");
+    double *dualRowSolution = lpSolver->dualRowSolution();
+    double *primalRowSolution = lpSolver->primalRowSolution();
+    double *dualColumnSolution = lpSolver->dualColumnSolution();
+    double *primalColumnSolution = lpSolver->primalColumnSolution();
+    if (mode) {
+      // swap
+      int k = numberRows;
+      numberRows = numberColumns;
+      numberColumns = k;
+      double *temp;
+      temp = dualRowSolution;
+      dualRowSolution = primalColumnSolution;
+      primalColumnSolution = temp;
+      temp = dualColumnSolution;
+      dualColumnSolution = primalRowSolution;
+      primalRowSolution = temp;
+    }
+    if (numberRows > numberRowsFile || numberColumns > numberColumnsFile) {
+      std::cout << "Mismatch on rows and/or columns - giving up" << std::endl;
+    } else {
+      lpSolver->setObjectiveValue(objectiveValue);
+      if (numberRows == numberRowsFile && numberColumns == numberColumnsFile) {
+        nRead = fread(primalRowSolution, sizeof(double), numberRows, fp);
+        if (nRead != static_cast< size_t >(numberRows))
+          throw("Error in fread");
+        nRead = fread(dualRowSolution, sizeof(double), numberRows, fp);
+        if (nRead != static_cast< size_t >(numberRows))
+          throw("Error in fread");
+        nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp);
+        if (nRead != static_cast< size_t >(numberColumns))
+          throw("Error in fread");
+        nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp);
+        if (nRead != static_cast< size_t >(numberColumns))
+          throw("Error in fread");
+      } else {
+        std::cout << "Mismatch on rows and/or columns - truncating" << std::endl;
+        double *temp = new double[CoinMax(numberRowsFile, numberColumnsFile)];
+        nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+        if (nRead != static_cast< size_t >(numberRowsFile))
+          throw("Error in fread");
+        CoinMemcpyN(temp, numberRows, primalRowSolution);
+        nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+        if (nRead != static_cast< size_t >(numberRowsFile))
+          throw("Error in fread");
+        CoinMemcpyN(temp, numberRows, dualRowSolution);
+        nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+        if (nRead != static_cast< size_t >(numberColumnsFile))
+          throw("Error in fread");
+        CoinMemcpyN(temp, numberColumns, primalColumnSolution);
+        nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+        if (nRead != static_cast< size_t >(numberColumnsFile))
+          throw("Error in fread");
+        CoinMemcpyN(temp, numberColumns, dualColumnSolution);
+        delete[] temp;
+      }
+      if (mode == 3) {
+        int i;
+        for (i = 0; i < numberRows; i++) {
+          primalRowSolution[i] = -primalRowSolution[i];
+          dualRowSolution[i] = -dualRowSolution[i];
+        }
+        for (i = 0; i < numberColumns; i++) {
+          primalColumnSolution[i] = -primalColumnSolution[i];
+          dualColumnSolution[i] = -dualColumnSolution[i];
+        }
+      }
+    }
+    fclose(fp);
+  } else {
+    std::cout << "Unable to open file " << fileName << std::endl;
+  }
+}
+// Dump a solution to file
+void saveSolution(const ClpSimplex *lpSolver, std::string fileName)
+{
+  if (strstr(fileName.c_str(), "_fix_read_")) {
+    FILE *fp = fopen(fileName.c_str(), "rb");
+    if (fp) {
+      ClpSimplex *solver = const_cast< ClpSimplex * >(lpSolver);
+      restoreSolution(solver, fileName, 0);
+      // fix all
+      int logLevel = solver->logLevel();
+      int iColumn;
+      int numberColumns = solver->numberColumns();
+      double *primalColumnSolution = solver->primalColumnSolution();
+      double *columnLower = solver->columnLower();
+      double *columnUpper = solver->columnUpper();
+      for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+        double value = primalColumnSolution[iColumn];
+        if (value > columnUpper[iColumn]) {
+          if (value > columnUpper[iColumn] + 1.0e-6 && logLevel > 1)
+            printf("%d value of %g - bounds %g %g\n",
+              iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+          value = columnUpper[iColumn];
+        } else if (value < columnLower[iColumn]) {
+          if (value < columnLower[iColumn] - 1.0e-6 && logLevel > 1)
+            printf("%d value of %g - bounds %g %g\n",
+              iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+          value = columnLower[iColumn];
+        }
+        columnLower[iColumn] = value;
+        columnUpper[iColumn] = value;
+      }
+      return;
+    }
+  }
+  FILE *fp = fopen(fileName.c_str(), "wb");
+  if (fp) {
+    int numberRows = lpSolver->numberRows();
+    int numberColumns = lpSolver->numberColumns();
+    double objectiveValue = lpSolver->objectiveValue();
+    size_t nWrite;
+    nWrite = fwrite(&numberRows, sizeof(int), 1, fp);
+    if (nWrite != 1)
+      throw("Error in fwrite");
+    nWrite = fwrite(&numberColumns, sizeof(int), 1, fp);
+    if (nWrite != 1)
+      throw("Error in fwrite");
+    nWrite = fwrite(&objectiveValue, sizeof(double), 1, fp);
+    if (nWrite != 1)
+      throw("Error in fwrite");
+    double *dualRowSolution = lpSolver->dualRowSolution();
+    double *primalRowSolution = lpSolver->primalRowSolution();
+    nWrite = fwrite(primalRowSolution, sizeof(double), numberRows, fp);
+    if (nWrite != static_cast< size_t >(numberRows))
+      throw("Error in fwrite");
+    nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp);
+    if (nWrite != static_cast< size_t >(numberRows))
+      throw("Error in fwrite");
+    double *dualColumnSolution = lpSolver->dualColumnSolution();
+    double *primalColumnSolution = lpSolver->primalColumnSolution();
+    nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp);
+    if (nWrite != static_cast< size_t >(numberColumns))
+      throw("Error in fwrite");
+    nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp);
+    if (nWrite != static_cast< size_t >(numberColumns))
+      throw("Error in fwrite");
+    fclose(fp);
+  } else {
+    std::cout << "Unable to open file " << fileName << std::endl;
+  }
+}
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/