/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/predefined

Bug Summary

File:	usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/predefined_ops.h
Warning:	line 43, column 16 Use of zero-allocated memory

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CglProbing.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D HAVE_CONFIG_H -I . -I . -I .. -I ./.. -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/coinmp/CoinUtils/src -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/coinmp/Osi/src/Osi -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/coinmp/CoinUtils/src -D NDEBUG -D CGL_BUILD -D PIC -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wwrite-strings -Wno-unknown-pragmas -Wno-long-long -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/coinmp/Cgl/src/CglProbing -ferror-limit 19 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ CglProbing.cpp

CglProbing.cpp

→

1// $Id: CglProbing.cpp 1123 2013-04-06 20:47:24Z stefan $
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).

6#include <cstdlib>
7#include <cstdio>
8#include <cmath>
9#include <cfloat>
10#include <cassert>
11#include <iostream>
12#define PROBING1000 0
13//#define PRINT_DEBUG
14//#define CGL_DEBUG 1
15//#undef NDEBUG
16#include "CoinPragma.hpp"
17#include "CoinHelperFunctions.hpp"
18#include "CoinPackedVector.hpp"
19#include "CoinPackedMatrix.hpp"
20#include "CoinFinite.hpp"
21#include "OsiRowCutDebugger.hpp"
22#include "CglProbing.hpp"
23//#define PROBING_EXTRA_STUFF true
24#define PROBING_EXTRA_STUFFfalse false
25#define FIXED_ALLOWANCE10 10
26#define SIZE_ROW_MULT4 4
27#define SIZE_ROW_ADD2000 2000
28typedef struct {double infeasibility;int sequence;} double_int_pair;
29class double_int_pair_compare {
30public:
bool operator() (double_int_pair x , double_int_pair y) const
{
  return ( x.infeasibility < y.infeasibility);
}
35};
36// for hashing
37typedef struct {
int index, next;
39} CoinHashLink;
40static double multiplier[] = {1.23456789e2,-9.87654321};
41static int hashCut (const OsiRowCut2 & x, int size) 
42{
int xN =x.row().getNumElements();
double xLb = x.lb();
double xUb = x.ub();
const int * xIndices = x.row().getIndices();
const double * xElements = x.row().getElements();
unsigned int hashValue;
double value=1.0;
if (xLb>-1.0e10)
  value += xLb*multiplier[0];
if (xUb<1.0e10)
  value += xUb*multiplier[1];
for( int j=0;j<xN;j++) {
  int xColumn = xIndices[j];
  double xValue = xElements[j];
  int k=(j&1);
  value += (j+1)*multiplier[k]*(xColumn+1)*xValue;
}
// should be compile time but too lazy for now
if (sizeof(value)>sizeof(hashValue)) {
  assert (sizeof(value)==2*sizeof(hashValue))(static_cast<void> (0));
  union { double d; int i[2]; } xx;
  xx.d = value;
  hashValue = (xx.i[0] + xx.i[1]);
} else {
  assert (sizeof(value)==sizeof(hashValue))(static_cast<void> (0));
  union { double d; unsigned int i[2]; } xx;
  xx.d = value;
  hashValue = xx.i[0];
}
return hashValue%(size);
73}
74static bool same (const OsiRowCut2 & x, const OsiRowCut2 & y) 
75{
int xN =x.row().getNumElements();
int yN =y.row().getNumElements();
bool identical=false;
if (xN==yN) {
  double xLb = x.lb();
  double xUb = x.ub();
  double yLb = y.lb();
  double yUb = y.ub();
  if (fabs(xLb-yLb)<1.0e-8&&fabs(xUb-yUb)<1.0e-8) {
    const int * xIndices = x.row().getIndices();
    const double * xElements = x.row().getElements();
    const int * yIndices = y.row().getIndices();
    const double * yElements = y.row().getElements();
    int j;
    for( j=0;j<xN;j++) {
if (xIndices[j]!=yIndices[j])
 break;
if (fabs(xElements[j]-yElements[j])>1.0e-12)
 break;
    }
    identical =  (j==xN);
  }
}
return identical;
100}
101class row_cut {
102public:

row_cut(int nRows, bool initialPass )
{
  numberCuts_=0;
  if (nRows<500) {
    maxSize_ = SIZE_ROW_MULT4*nRows + SIZE_ROW_ADD2000;
  } else if (nRows<5000) {
    maxSize_ = (SIZE_ROW_MULT4*nRows + SIZE_ROW_ADD2000)>>1;
  } else if (nRows<10000) {
    maxSize_ = (SIZE_ROW_MULT4*(nRows>>1) + SIZE_ROW_ADD2000)>>1;
  } else {
    maxSize_ = (SIZE_ROW_MULT4*CoinMin(nRows,100000) + SIZE_ROW_ADD2000)>>2;
  }
  size_ = (maxSize_>>3)+10;
  if (initialPass)
    size_ = size_>>1;
  if (size_<1000)
    hashSize_=4*size_;
  else
    hashSize_=2*size_;
  nRows_ = nRows;
  rowCut_ = new  OsiRowCut2 * [size_];
  hash_ = new CoinHashLink[hashSize_];
  for (int i=0;i<hashSize_;i++) {
    hash_[i].index=-1;
    hash_[i].next=-1;
  }
  numberCuts_=0;
  lastHash_=-1;
}
~row_cut()
{
  for (int i=0;i<numberCuts_;i++)
    delete rowCut_[i];
  delete [] rowCut_;
  delete [] hash_;
}
OsiRowCut2 * cut(int i) const
{ return rowCut_[i];}
int numberCuts() const
{ return numberCuts_;}
inline bool outOfSpace() const
{ return maxSize_==numberCuts_;}
OsiRowCut2 ** rowCut_;
/// Hash table
CoinHashLink *hash_;
int size_;
int maxSize_;
int hashSize_;
int nRows_;
int numberCuts_;
int lastHash_;
// Return 0 if added, 1 if not, -1 if not added because of space
int addCutIfNotDuplicate(OsiRowCut & cut,int whichRow=-1)
{
  if (numberCuts_==size_&&numberCuts_<maxSize_) {
    size_ = CoinMin(2*size_+100,maxSize_);
    if (size_<1000)
hashSize_=4*size_;
    else
hashSize_=2*size_;
164#ifdef COIN_DEVELOP
    printf("increaing size from %d to %d (hash size %d, maxsize %d)\n",
    numberCuts_,size_,hashSize_,maxSize_);
167#endif
    OsiRowCut2 ** temp = new  OsiRowCut2 * [size_];
    delete [] hash_;
    hash_ = new CoinHashLink[hashSize_];
    for (int i=0;i<hashSize_;i++) {
hash_[i].index=-1;
hash_[i].next=-1;
    }
    for (int i=0;i<numberCuts_;i++) {
temp[i]=rowCut_[i];
int ipos = hashCut(*temp[i],hashSize_);
int found = -1;
int jpos=ipos;
while ( true ) {
 int j1 = hash_[ipos].index;
 
 if ( j1 >= 0 ) {
   if ( !same(*temp[i],*temp[j1]) ) {
     int k = hash_[ipos].next;
     if ( k != -1 )
ipos = k;
     else
break;
   } else {
     found = j1;
     break;
   }
 } else {
   break;
 }
}
if (found<0) {
 assert (hash_[ipos].next==-1)(static_cast<void> (0));
 if (ipos==jpos) {
   // first
   hash_[ipos].index=i;
 } else {
   // find next space 
   while ( true ) {
     ++lastHash_;
     assert (lastHash_<hashSize_)(static_cast<void> (0));
     if ( hash_[lastHash_].index == -1 ) 
break;
   }
   hash_[ipos].next = lastHash_;
   hash_[lastHash_].index = i;
 }
}
    }
    delete [] rowCut_;
    rowCut_ = temp;
  }
  if (numberCuts_<size_) {
    double newLb = cut.lb();
    double newUb = cut.ub();
    CoinPackedVector vector = cut.row();
    int numberElements =vector.getNumElements();
    int * newIndices = vector.getIndices();
    double * newElements = vector.getElements();
    CoinSort_2(newIndices,newIndices+numberElements,newElements);
    int i;
    bool bad=false;
    for (i=0;i<numberElements;i++) {
double value = fabs(newElements[i]);
if (value<1.0e-12||value>1.0e12) 
 bad=true;
    }
    if (bad)
return 1;
    OsiRowCut2 newCut(whichRow);
    newCut.setLb(newLb);
    newCut.setUb(newUb);
    newCut.setRow(vector);
    int ipos = hashCut(newCut,hashSize_);
    int found = -1;
    int jpos=ipos;
    while ( true ) {
int j1 = hash_[ipos].index;

if ( j1 >= 0 ) {
 if ( !same(newCut,*rowCut_[j1]) ) {
   int k = hash_[ipos].next;
   if ( k != -1 )
     ipos = k;
   else
     break;
 } else {
   found = j1;
   break;
 }
} else {
 break;
}
    }
    if (found<0) {
assert (hash_[ipos].next==-1)(static_cast<void> (0));
if (ipos==jpos) {
 // first
 hash_[ipos].index=numberCuts_;
} else {
 // find next space 
 while ( true ) {
   ++lastHash_;
   assert (lastHash_<hashSize_)(static_cast<void> (0));
   if ( hash_[lastHash_].index == -1 ) 
     break;
 }
 hash_[ipos].next = lastHash_;
 hash_[lastHash_].index = numberCuts_;
}
      OsiRowCut2 * newCutPtr = new OsiRowCut2(whichRow);
      newCutPtr->setLb(newLb);
      newCutPtr->setUb(newUb);
      newCutPtr->setRow(vector);
      rowCut_[numberCuts_++]=newCutPtr;
      return 0;
    } else {
      return 1;
    }
  } else {
    return -1;
  }
}
void addCuts(OsiCuts & cs, OsiRowCut ** whichRow,int iPass)
{
  int numberCuts=cs.sizeRowCuts();
  int i ;
  if (numberCuts_<nRows_) {
    if ((iPass&1)==1) {
for (i=0;i<numberCuts_;i++) {
 cs.insert(*rowCut_[i]);
 if (whichRow) {
   int iRow= rowCut_[i]->whichRow();
   if (iRow>=0&&!whichRow[iRow])
     whichRow[iRow]=cs.rowCutPtr(numberCuts);;
 }
 numberCuts++;
}
    } else {
for (i=numberCuts_-1;i>=0;i--) {
 cs.insert(*rowCut_[i]);
 if (whichRow) {
   int iRow= rowCut_[i]->whichRow();
   if (iRow>=0&&!whichRow[iRow])
     whichRow[iRow]=cs.rowCutPtr(numberCuts);;
 }
 numberCuts++;
}
    }
  } else {
    // just best
    double * effectiveness = new double[numberCuts_];
    int iCut=0;
    for (i=0;i<numberCuts_;i++) {
      double value = -rowCut_[i]->effectiveness();
if (whichRow) {
 int iRow= rowCut_[i]->whichRow();
 if (iRow>=0)
   value -= 1.0e10;
}
      effectiveness[iCut++]=value;
    }
    std::sort(effectiveness,effectiveness+numberCuts_);
    double threshold = -1.0e20;
    if (iCut>nRows_)
      threshold = effectiveness[nRows_];
    for ( i=0;i<numberCuts_;i++) {
      if (rowCut_[i]->effectiveness()>threshold) {
        cs.insert(*rowCut_[i]);
        if (whichRow) {
          int iRow= rowCut_[i]->whichRow();
          if (iRow>=0&&!whichRow[iRow])
            whichRow[iRow]=cs.rowCutPtr(numberCuts);;
        }
        numberCuts++;
      }
    }
    delete[] effectiveness ;
  }
  for (i = 0 ; i < numberCuts_ ; i++)
  { delete rowCut_[i] ;
    rowCut_[i] = 0 ; }
  numberCuts_=0;
}
351};
352// Adds in cut to list 
353#ifdef CGL_DEBUG
354// Checks bounds okay against debugger
355static void checkBounds(const OsiRowCutDebugger * debugger,OsiColCut & cut)
356{
if (debugger) {
  // on optimal path
  const double * optimal = debugger->optimalSolution();
  int i;
  int nIndex;
  const double * values;
  const int * index;
  const CoinPackedVector & lbs = cut.lbs();
  values = lbs.getElements();
  nIndex = lbs.getNumElements();
  index = lbs.getIndices();
  for (i=0;i<nIndex;i++) {
    double value=values[i];
    int iColumn = index[i];
    printf("%d optimal %g lower %g\n",iColumn,optimal[iColumn],value);
    assert(value<=optimal[iColumn]+1.0e-5)(static_cast<void> (0));
  }
  const CoinPackedVector & ubs = cut.ubs();
  values = ubs.getElements();
  nIndex = ubs.getNumElements();
  index = ubs.getIndices();
  for (i=0;i<nIndex;i++) {
    double value=values[i];
    int iColumn = index[i];
    printf("%d optimal %g upper %g\n",iColumn,optimal[iColumn],value);
    assert(value>=optimal[iColumn]-1.0e-5)(static_cast<void> (0));
  }
}
385}
386#endif
387#define CGL_REASONABLE_INTEGER_BOUND1.23456789e10 1.23456789e10
388// This tightens column bounds (and can declare infeasibility)
389// It may also declare rows to be redundant
390int 
391CglProbing::tighten(double *colLower, double * colUpper,
                  const int *column, const double *rowElements, 
                  const CoinBigIndex *rowStart, 
    const CoinBigIndex * rowStartPos,const int * rowLength,
                  double *rowLower, double *rowUpper, 
                  int nRows,int nCols,char * intVar,int maxpass,
                  double tolerance)
398{
int i, j, k, kre;
int krs;
int dolrows;
int iflagu, iflagl;
int ntotal=0,nchange=1,jpass=0;
double dmaxup, dmaxdown, dbound;
int ninfeas=0;
// For clique stuff
double * cliqueMin=NULL__null;
double * cliqueMax=NULL__null;
// And second best ones
double * cliqueMin2 = NULL__null;
double * cliqueMax2 = NULL__null;
if (cliqueRowStart_&&numberRows_&&cliqueRowStart_[numberRows_]) {
  cliqueMin = new double[nCols];
  cliqueMax = new double[nCols];
  cliqueMin2 = new double[nCols];
  cliqueMax2 = new double[nCols];
} else {
  // do without cliques and using sorted version
  assert (rowStartPos)(static_cast<void> (0));
  while(nchange) {
    nchange = 0; 
    if (jpass==maxpass) break;
    jpass++;
    dolrows = (jpass & 1) == 1;
    
    for (i = 0; i < nRows; ++i) {
if (rowLower[i]>-1.0e20||rowUpper[i]<1.0e20) {
 int iflagu = 0;
 int iflagl = 0;
 double dmaxup = 0.0;
 double dmaxdown = 0.0;
 int krs = rowStart[i];
 int krs2 = rowStartPos[i];
 int kre = rowStart[i]+rowLength[i];
 
 /* ------------------------------------------------------------*/
 /* Compute L(i) and U(i) */
 /* ------------------------------------------------------------*/
 for (k = krs; k < krs2; ++k) {
   double value=rowElements[k];
   int j = column[k];
   if (colUpper[j] < 1.0e12) 
     dmaxdown += colUpper[j] * value;
   else
     ++iflagl;
   if (colLower[j] > -1.0e12) 
     dmaxup += colLower[j] * value;
   else
     ++iflagu;
 }
 for (k = krs2; k < kre; ++k) {
   double value=rowElements[k];
   int j = column[k];
   if (colUpper[j] < 1.0e12) 
     dmaxup += colUpper[j] * value;
   else
     ++iflagu;
   if (colLower[j] > -1.0e12) 
     dmaxdown += colLower[j] * value;
   else
     ++iflagl;
 }
 if (iflagu)
   dmaxup=1.0e31;
 if (iflagl)
   dmaxdown=-1.0e31;
 if (dmaxup <= rowUpper[i] + tolerance && dmaxdown >= rowLower[i] - tolerance) {
   /*
    * The sum of the column maxs is at most the row ub, and
    * the sum of the column mins is at least the row lb;
    * this row says nothing at all.
    * I suspect that this corresponds to
    * an implied column singleton in the paper (viii, on p. 325),
    * where the singleton in question is the row slack.
    */
   ++nchange;
   rowLower[i]=-COIN_DBL_MAX;
   rowUpper[i]=COIN_DBL_MAX;
 } else {
   if (dmaxup < rowLower[i] -tolerance || dmaxdown > rowUpper[i]+tolerance) {
     ninfeas++;
     break;
   }
   /*        Finite U(i) */
   /* -------------------------------------------------------------*/
   /* below is deliberate mistake (previously was by chance) */
   /*        never do both */
   if (iflagu == 0 && rowLower[i] > 0.0 && iflagl == 0 && rowUpper[i] < 1e15) {
     if (dolrows) {
iflagu = 1;
     } else {
iflagl = 1;
     }
   }
   if (iflagu == 0 && rowLower[i] > -1e15) {
     for (k = krs; k < kre; ++k) {
double value=rowElements[k];
j = column[k];
if (value > 0.0) {
  if (colUpper[j] < 1.0e12) {
    dbound = colUpper[j] + (rowLower[i] - dmaxup) / value;
    if (dbound > colLower[j] + 1.0e-8) {
      /* we can tighten the lower bound */
      /* the paper mentions this as a possibility on p. 227 */
      colLower[j] = dbound;
      ++nchange;
      
      /* this may have fixed the variable */
      /* I believe that this roughly corresponds to a
       * forcing constraint in the paper (p. 226).
       * If there is a forcing constraint (with respect
       * to the original, untightened bounds), then in this 
       * loop we will go through all the columns and fix
       * each of them to their implied bound, rather than
       * determining that the row as a whole is forced
       * and just fixing them without doing computation for
       * each column (as in the paper).
       * By doing it this way, we can tighten bounds and
       * get forcing constraints for free.
       */
      if (colUpper[j] - colLower[j] <= tolerance) {
	/* --------------------------------------------------*/
	/*                check if infeasible !!!!! */
	/* --------------------------------------------------*/
	if (colUpper[j] - colLower[j] < -100.0*tolerance) {
	  ninfeas++;
	}
      }
    }
  }
} else {
  if (colLower[j] > -1.0e12) {
    dbound = colLower[j] + (rowLower[i] - dmaxup) / value;
    if (dbound < colUpper[j] - 1.0e-8) {
      colUpper[j] = dbound;
      ++nchange;
      if (colUpper[j] - colLower[j] <= tolerance) {
	/* --------------------------------------------------*/
	/*                check if infeasible !!!!! */
	/* --------------------------------------------------*/
	if (colUpper[j] - colLower[j] < -100.0*tolerance) {
	  ninfeas++;
	}
      }
    }
  }
}
     }
   }
   
   /* ----------------------------------------------------------------*/
   /*        Finite L(i) */
   /* ----------------------------------------------------------------*/
   if (iflagl == 0 && rowUpper[i] < 1e15) {
     for (k = krs; k < kre; ++k) {
double value=rowElements[k];
j = column[k];
if (value < 0.0) {
  if (colUpper[j] < 1.0e12) {
    dbound = colUpper[j] + (rowUpper[i] - dmaxdown) / value;
    if (dbound > colLower[j] + 1.0e-8) {
      colLower[j] = dbound;
      ++nchange;
      if (! (colUpper[j] - colLower[j] > tolerance)) {
	/* --------------------------------------------------*/
	/*                check if infeasible !!!!! */
	/* --------------------------------------------------*/
	if (colUpper[j] - colLower[j] < -100.0*tolerance) {
	  ninfeas++;
	}
      }
    }
  } 
} else {
  if (colLower[j] > -1.0e12) {
    dbound = colLower[j] + (rowUpper[i] - dmaxdown) / value;
    if (dbound < colUpper[j] - 1.0e-8) {
      colUpper[j] = dbound;
      ++nchange;
      if (! (colUpper[j] - colLower[j] > tolerance)) {
	/* --------------------------------------------------*/
	/*                check if infeasible !!!!! */
	/* --------------------------------------------------*/
	if (colUpper[j] - colLower[j] < -100.0*tolerance) {
	  ninfeas++;
	}
      }
    }
  }
}
     }
   }
 }
}
    }
    for (j = 0; j < nCols; ++j) {
if (intVar[j]) {
 if (colUpper[j]-colLower[j]>1.0e-8) {
   if (floor(colUpper[j]+1.0e-4)<colUpper[j]) 
     nchange++;
   // clean up anyway
   colUpper[j]=floor(colUpper[j]+1.0e-4);
   if (ceil(colLower[j]-1.0e-4)>colLower[j]) 
     nchange++;
   // clean up anyway
   colLower[j]=ceil(colLower[j]-1.0e-4);
   if (colUpper[j]<colLower[j]) {
     /*printf("infeasible\n");*/
     ninfeas++;
   }
 }
}
    }
    if (ninfeas) break;
  }
  return (ninfeas);
}

while(nchange) {
  int ilbred = 0; /* bounds reduced */
  int iubred = 0; /* bounds reduced */
  int nrwdrp = 0; /* redundant rows */
  if (jpass==maxpass) break;
  jpass++;
  dolrows = (jpass & 1) == 1;
  
  for (i = 0; i < nRows; ++i) {
    bool cliqueChanges=false;
    if (rowLower[i]>-1.0e20||rowUpper[i]<1.0e20) {
iflagu = 0;
iflagl = 0;
dmaxup = 0.0;
dmaxdown = 0.0;
krs = rowStart[i];
kre = rowStart[i]+rowLength[i];

/* ------------------------------------------------------------*/
/* Compute L(i) and U(i) */
/* ------------------------------------------------------------*/
      if (!cliqueMin||i>=numberRows_||cliqueRowStart_[i]==cliqueRowStart_[i+1]) {
        // without cliques
        for (k = krs; k < kre; ++k) {
          double value=rowElements[k];
          j = column[k];
          if (value > 0.0) {
            if (colUpper[j] < 1.0e12) 
              dmaxup += colUpper[j] * value;
     else
              ++iflagu;
            if (colLower[j] > -1.0e12) 
              dmaxdown += colLower[j] * value;
     else
              ++iflagl;
          } else if (value<0.0) {
            if (colUpper[j] < 1.0e12) 
              dmaxdown += colUpper[j] * value;
     else
              ++iflagl;
            if (colLower[j] > -1.0e12) 
              dmaxup += colLower[j] * value;
     else
              ++iflagu;
          }
        }
 if (iflagu)
   dmaxup=1.0e31;
 if (iflagl)
   dmaxdown=-1.0e31;
      } else {
        // with cliques
        int nClique=0;
        int bias = cliqueRowStart_[i]-krs;
        double dmaxup2=0.0;
        double dmaxdown2=0.0;
        double sumZeroFixes=0.0;
        for (k = krs; k < kre; ++k) {
          double value=rowElements[k];
          j = column[k];
          int iClique = sequenceInCliqueEntry(cliqueRow_[k+bias]);
          bool oneFixes = oneFixesInCliqueEntry(cliqueRow_[k+bias]);
          if (iClique>=numberColumns_||colUpper[j]==colLower[j]) {
            if (value > 0.0) {
              if (colUpper[j] >= 1.0e12) {
                dmaxup = 1e31;
                ++iflagu;
              } else {
                dmaxup += colUpper[j] * value;
              }
              if (colLower[j] <= -1.0e12) {
                dmaxdown = -1e31;
                ++iflagl;
              } else {
                dmaxdown += colLower[j] * value;
              }
            } else if (value<0.0) {
              if (colUpper[j] >= 1.0e12) {
                dmaxdown = -1e31;
                ++iflagl;
              } else {
                dmaxdown += colUpper[j] * value;
              }
              if (colLower[j] <= -1.0e12) {
                dmaxup = 1e31;
                ++iflagu;
              } else {
                dmaxup += colLower[j] * value;
              }
            }
          } else {
            // clique may help
            if (iClique>=nClique) {
              //zero out
              for (int j=nClique;j<=iClique;j++) {
                cliqueMin[j]=0.0;
                cliqueMax[j]=0.0;
                cliqueMin2[j]=0.0;
                cliqueMax2[j]=0.0;
              }
              nClique=iClique+1;
            }
            //  Update best and second best
            if (oneFixes) {
              if (value > 0.0) {
                dmaxup2 += value;
                cliqueMax2[iClique] = cliqueMax[iClique];
                cliqueMax[iClique] = CoinMax(cliqueMax[iClique],value);
              } else if (value<0.0) {
                dmaxdown2 +=  value;
                cliqueMin2[iClique] = cliqueMin[iClique];
                cliqueMin[iClique] = CoinMin(cliqueMin[iClique],value);
              }
            } else {
              sumZeroFixes += value;
              if (value > 0.0) {
                dmaxup2 += value;
                cliqueMin2[iClique] = cliqueMin[iClique];
                cliqueMin[iClique] = CoinMin(cliqueMin[iClique],-value);
              } else if (value<0.0) {
                dmaxdown2 +=  value;
                cliqueMax2[iClique] = cliqueMax[iClique];
                cliqueMax[iClique] = CoinMax(cliqueMax[iClique],-value);
              }
            }
          }
        }
        double dmaxup3 = dmaxup + sumZeroFixes;
        double dmaxdown3 = dmaxdown + sumZeroFixes;
        for (int iClique=0;iClique<nClique;iClique++) {
          dmaxup3 += cliqueMax[iClique];
          dmaxdown3 += cliqueMin[iClique];
        }
        dmaxup += dmaxup2;
        dmaxdown += dmaxdown2;
        assert (dmaxup3<=dmaxup+1.0e-8)(static_cast<void> (0));
        assert (dmaxdown3>=dmaxdown-1.0e-8)(static_cast<void> (0));
        if (dmaxup3<dmaxup-1.0e-8||dmaxdown3>dmaxdown+1.0e-8) {
          cliqueChanges=true;
          //printf("normal min/max %g , %g clique %g , %g\n",
          //     dmaxdown,dmaxup,dmaxdown3,dmaxup3);
          dmaxdown=dmaxdown3;
          dmaxup=dmaxup3;
        }
      }
if (dmaxup <= rowUpper[i] + tolerance && dmaxdown >= rowLower[i] - tolerance) {
 /*
  * The sum of the column maxs is at most the row ub, and
  * the sum of the column mins is at least the row lb;
  * this row says nothing at all.
  * I suspect that this corresponds to
  * an implied column singleton in the paper (viii, on p. 325),
  * where the singleton in question is the row slack.
  */
 ++nrwdrp;
 rowLower[i]=-COIN_DBL_MAX;
 rowUpper[i]=COIN_DBL_MAX;
} else {
 if (dmaxup < rowLower[i] -tolerance || dmaxdown > rowUpper[i]+tolerance) {
   ninfeas++;
          assert (!cliqueChanges)(static_cast<void> (0));
   break;
 }
 /*        Finite U(i) */
 /* -------------------------------------------------------------*/
 /* below is deliberate mistake (previously was by chance) */
 /*        never do both */
 if (iflagu == 0 && rowLower[i] > 0.0 && iflagl == 0 && rowUpper[i] < 1e15) {
          if (dolrows) {
            iflagu = 1;
          } else {
            iflagl = 1;
          }
        }
        if (!cliqueChanges) {
          // without cliques
          if (iflagu == 0 && rowLower[i] > -1e15) {
            for (k = krs; k < kre; ++k) {
              double value=rowElements[k];
              j = column[k];
              if (value > 0.0) {
                if (colUpper[j] < 1.0e12) {
                  dbound = colUpper[j] + (rowLower[i] - dmaxup) / value;
                  if (dbound > colLower[j] + 1.0e-8) {
                    /* we can tighten the lower bound */
                    /* the paper mentions this as a possibility on p. 227 */
                    colLower[j] = dbound;
                    ++ilbred;
                    
                    /* this may have fixed the variable */
                    /* I believe that this roughly corresponds to a
                     * forcing constraint in the paper (p. 226).
                     * If there is a forcing constraint (with respect
                     * to the original, untightened bounds), then in this 
                     * loop we will go through all the columns and fix
                     * each of them to their implied bound, rather than
                     * determining that the row as a whole is forced
                     * and just fixing them without doing computation for
                     * each column (as in the paper).
                     * By doing it this way, we can tighten bounds and
                     * get forcing constraints for free.
                     */
                    if (colUpper[j] - colLower[j] <= tolerance) {
                      /* --------------------------------------------------*/
                      /*                check if infeasible !!!!! */
                      /* --------------------------------------------------*/
                      if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                        ninfeas++;
                      }
                    }
                  }
                }
              } else {
                if (colLower[j] > -1.0e12) {
                  dbound = colLower[j] + (rowLower[i] - dmaxup) / value;
                  if (dbound < colUpper[j] - 1.0e-8) {
                    colUpper[j] = dbound;
                    ++iubred;
                    if (colUpper[j] - colLower[j] <= tolerance) {
                      /* --------------------------------------------------*/
                      /*                check if infeasible !!!!! */
                      /* --------------------------------------------------*/
                      if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                        ninfeas++;
                      }
                    }
                  }
                }
              }
            }
          }
          
          /* ----------------------------------------------------------------*/
          /*        Finite L(i) */
          /* ----------------------------------------------------------------*/
          if (iflagl == 0 && rowUpper[i] < 1e15) {
            for (k = krs; k < kre; ++k) {
              double value=rowElements[k];
              j = column[k];
              if (value < 0.0) {
                if (colUpper[j] < 1.0e12) {
                  dbound = colUpper[j] + (rowUpper[i] - dmaxdown) / value;
                  if (dbound > colLower[j] + 1.0e-8) {
                    colLower[j] = dbound;
                    ++ilbred;
                    if (! (colUpper[j] - colLower[j] > tolerance)) {
                      /* --------------------------------------------------*/
                      /*                check if infeasible !!!!! */
                      /* --------------------------------------------------*/
                      if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                        ninfeas++;
                      }
                    }
                  }
                } 
              } else {
                if (colLower[j] > -1.0e12) {
                  dbound = colLower[j] + (rowUpper[i] - dmaxdown) / value;
                  if (dbound < colUpper[j] - 1.0e-8) {
                    colUpper[j] = dbound;
                    ++iubred;
                    if (! (colUpper[j] - colLower[j] > tolerance)) {
                      /* --------------------------------------------------*/
                      /*                check if infeasible !!!!! */
                      /* --------------------------------------------------*/
                      if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                        ninfeas++;
                      }
                    }
                  }
                }
              }
            }
          }
        } else {
          // with cliques
          int bias = cliqueRowStart_[i]-krs;
          if (iflagu == 0 && rowLower[i] > -1e15) {
            for (k = krs; k < kre; ++k) {
              double value=rowElements[k];
              j = column[k];
              int iClique = sequenceInCliqueEntry(cliqueRow_[k+bias]);
              //bool oneFixes = (cliqueRow_[k+bias].oneFixes!=0);
              if (iClique>=numberColumns_) {
                if (value > 0.0) {
                  if (colUpper[j] < 1.0e12) {
                    dbound = colUpper[j] + (rowLower[i] - dmaxup) / value;
                    if (dbound > colLower[j] + 1.0e-8) {
                      /* we can tighten the lower bound */
                      /* the paper mentions this as a possibility on p. 227 */
                      colLower[j] = dbound;
                      ++ilbred;
                      
                      /* this may have fixed the variable */
                      /* I believe that this roughly corresponds to a
                       * forcing constraint in the paper (p. 226).
                       * If there is a forcing constraint (with respect
                       * to the original, untightened bounds), then in this 
                       * loop we will go through all the columns and fix
                       * each of them to their implied bound, rather than
                       * determining that the row as a whole is forced
                       * and just fixing them without doing computation for
                       * each column (as in the paper).
                       * By doing it this way, we can tighten bounds and
                       * get forcing constraints for free.
                       */
                      if (colUpper[j] - colLower[j] <= tolerance) {
                        /* --------------------------------------------------*/
                        /*                check if infeasible !!!!! */
                        /* --------------------------------------------------*/
                        if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                          ninfeas++;
                        }
                      }
933#if 0
                    } else if (intVar[j]==1 && rowUpper[i]>1.0e20) {
                      // can we modify coefficient
                      if (dmaxdown+value>rowLower[i]+1.0e-8) {
                        assert (dmaxdown<rowLower[i]+1.0e-8)(static_cast<void> (0));
                        double change = dmaxdown+value - rowLower[i];
                        double newValue = value - change;
                        if (newValue<1.0e-12)
                          newValue=0.0;
                        printf("Could change value from %g to %g\n",
                               value,newValue);
                        // dmaxup -= change; 
                      }
946#endif
                    }
                  }
                } else {
                  if (colLower[j] > -1.0e12) {
                    dbound = colLower[j] + (rowLower[i] - dmaxup) / value;
                    if (dbound < colUpper[j] - 1.0e-8) {
                      colUpper[j] = dbound;
                      ++iubred;
                      if (colUpper[j] - colLower[j] <= tolerance) {
                        /* --------------------------------------------------*/
                        /*                check if infeasible !!!!! */
                        /* --------------------------------------------------*/
                        if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                          ninfeas++;
                        }
                      }
963#if 0
                    } else if (intVar[j]==1 && rowUpper[i]>1.0e20) {
                      // can we modify coefficient
                      if (dmaxdown-value>rowLower[i]+1.0e-8) {
                        assert (dmaxdown<rowLower[i]+1.0e-8)(static_cast<void> (0));
                        double change = dmaxdown-value-rowLower[i];
                        double newValue = value+change;
                        double newLower = rowLower[i]+change;
                        if (newValue<1.0e-12)
                          newValue=0.0;
                        printf("Could change value from %g to %g and lorow from %g to %g\n",
                               value,newValue,rowLower[i],newLower);
                       // dmaxdown += change                          
                      }
977#endif
                    }
                  }
                }
              } else if (colUpper[j]>colLower[j]) {
                // in clique
                // adjustment
                double dmaxup2=dmaxup;
                assert (cliqueMax[iClique]>=0)(static_cast<void> (0));
                assert (cliqueMax2[iClique]>=0)(static_cast<void> (0));
                /* get max up if at other bound
                   May not go down at all but will not go up */
                if (fabs(value)==fabs(cliqueMax[iClique]))
                  dmaxup2 -= cliqueMax[iClique]-cliqueMax2[iClique];
                if (dmaxup2<rowLower[i]-1.0e-8) {
                  /* --------------------------------------------------*/
                  /*                check if infeasible !!!!! */
                  /* --------------------------------------------------*/
                  if ( dmaxup<rowLower[i]-1.0e-8) {
                    ninfeas++;
                  } else {
                    if (value > 0.0) {
                      colLower[j] = 1.0;
                      ++ilbred;
                    } else {
                      colUpper[j] = 0.0;
                      ++iubred;
                    }
                  }
                }
              }
            }
          }
          
          /* ----------------------------------------------------------------*/
          /*        Finite L(i) */
          /* ----------------------------------------------------------------*/
          if (iflagl == 0 && rowUpper[i] < 1e15) {
            for (k = krs; k < kre; ++k) {
              double value=rowElements[k];
              j = column[k];
              int iClique = sequenceInCliqueEntry(cliqueRow_[k+bias]);
              //bool oneFixes = (cliqueRow_[k+bias].oneFixes!=0);
              if (iClique>=numberColumns_) {
                if (value < 0.0) {
                  if (colUpper[j] < 1.0e12) {
                    dbound = colUpper[j] + (rowUpper[i] - dmaxdown) / value;
                    if (dbound > colLower[j] + 1.0e-8) {
                      colLower[j] = dbound;
                      ++ilbred;
                      if (! (colUpper[j] - colLower[j] > tolerance)) {
                        /* --------------------------------------------------*/
                        /*                check if infeasible !!!!! */
                        /* --------------------------------------------------*/
                        if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                          ninfeas++;
                        }
                      }
1035#if 0
                    } else if (intVar[j]==1 && rowLower[i]<-1.0e20) {
                      // can we modify coefficient
                      if (dmaxup+value<rowUpper[i]-1.0e-8) {
                        assert (dmaxup>rowUpper[i]-1.0e-8)(static_cast<void> (0));
                        double change = dmaxup+value - rowUpper[i];
                        double newValue = value - change;
                        if (newValue<1.0e-12)
                          newValue=0.0;
                        printf("Could change value from %g to %g b\n",
                               value,newValue);
                        // dmaxdown -= change; 
                      }
1048#endif
                    }
                  } 
                } else {
                  if (colLower[j] > -1.0e12) {
                    dbound = colLower[j] + (rowUpper[i] - dmaxdown) / value;
                    if (dbound < colUpper[j] - 1.0e-8) {
                      colUpper[j] = dbound;
                      ++iubred;
                      if (! (colUpper[j] - colLower[j] > tolerance)) {
                        /* --------------------------------------------------*/
                        /*                check if infeasible !!!!! */
                        /* --------------------------------------------------*/
                        if (colUpper[j] - colLower[j] < -100.0*tolerance) {
                          ninfeas++;
                        }
                      }
1065#if 0
                    } else if (intVar[j]==1 && rowLower[i]<-1.0e20) {
                      // can we modify coefficient
                      if (dmaxup-value<rowUpper[i]-1.0e-8) {
                        assert (dmaxup>rowUpper[i]-1.0e-8)(static_cast<void> (0));
                        double change = dmaxup-value-rowUpper[i];
                        double newValue = value+change;
                        double newUpper = rowUpper[i]+change;
                        if (newValue<1.0e-12)
                          newValue=0.0;
                        printf("Could change value from %g to %g and uprow from %g to %g b\n",
                               value,newValue,rowLower[i],newUpper);
                       // dmaxup += change                          
                      }
1079#endif
                    }
                  }
                }
              } else if (colUpper[j]>colLower[j]) {
                // in clique
                // adjustment
                double dmaxdown2=dmaxdown;
                assert (cliqueMin[iClique]<=0)(static_cast<void> (0));
                assert (cliqueMin2[iClique]<=0)(static_cast<void> (0));
                /* get max down if this is at other bound
                   May not go up at all but will not go down */
                if (fabs(value)==fabs(cliqueMin[iClique]))
                  dmaxdown2 -= cliqueMin[iClique]-cliqueMin2[iClique];
                if (dmaxdown2>rowUpper[i]+1.0e-8) {
                  /* --------------------------------------------------*/
                  /*                check if infeasible !!!!! */
                  /* --------------------------------------------------*/
                  if ( dmaxdown>rowUpper[i]+1.0e-8) {
                    ninfeas++;
                  } else {
                    if (value < 0.0) {
                      colLower[j] = 1.0;
                      ++ilbred;
                    } else {
                      colUpper[j] = 0.0;
                      ++iubred;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  for (j = 0; j < nCols; ++j) {
    if (intVar[j]) {
if (colUpper[j]-colLower[j]>1.0e-8) {
 if (floor(colUpper[j]+1.0e-4)<colUpper[j]) 
   nchange++;
 // clean up anyway
 colUpper[j]=floor(colUpper[j]+1.0e-4);
 if (ceil(colLower[j]-1.0e-4)>colLower[j]) 
   nchange++;
 // clean up anyway
 colLower[j]=ceil(colLower[j]-1.0e-4);
 if (colUpper[j]<colLower[j]) {
   /*printf("infeasible\n");*/
   ninfeas++;
 }
}
    }
  }
  nchange=ilbred+iubred+nrwdrp;
  ntotal += nchange;
  if (ninfeas) break;
}
delete [] cliqueMin;
delete [] cliqueMax;
delete [] cliqueMin2;
delete [] cliqueMax2;
return (ninfeas);
1143}
1144// This just sets minima and maxima on rows
1145void 
1146CglProbing::tighten2(double *colLower, double * colUpper,
     const int *column, const double *rowElements, 
     const CoinBigIndex *rowStart, 
     const int * rowLength,
     double *rowLower, double *rowUpper, 
     double * minR, double * maxR, int * markR,
     int nRows)
1153{
int i, j, k, kre;
int krs;
int iflagu, iflagl;
double dmaxup, dmaxdown;

for (i = 0; i < nRows; ++i) {
  if (rowLower[i]>-1.0e20||rowUpper[i]<1.0e20) {
    iflagu = 0;
    iflagl = 0;
    dmaxup = 0.0;
    dmaxdown = 0.0;
    krs = rowStart[i];
    kre = rowStart[i]+rowLength[i];
    
    /* ------------------------------------------------------------*/
    /* Compute L(i) and U(i) */
    /* ------------------------------------------------------------*/
    for (k = krs; k < kre; ++k) {
double value=rowElements[k];
j = column[k];
if (value > 0.0) {
 if (colUpper[j] < 1.0e12) 
   dmaxup += colUpper[j] * value;
 else
   ++iflagu;
 if (colLower[j] > -1.0e12) 
   dmaxdown += colLower[j] * value;
 else
   ++iflagl;
} else if (value<0.0) {
 if (colUpper[j] < 1.0e12) 
   dmaxdown += colUpper[j] * value;
 else
   ++iflagl;
 if (colLower[j] > -1.0e12) 
   dmaxup += colLower[j] * value;
 else
   ++iflagu;
}
    }
    if (iflagu)
maxR[i]=1.0e60;
    else
maxR[i]=dmaxup;
    if (iflagl) 
minR[i]=-1.0e60;
    else
minR[i]=dmaxdown;
1202#if 0
    if (minR[i]<-1.0e10&&maxR[i]>1.0e10) {
markR[i]=-2;
    } else {
1206#endif
markR[i]=-1;
1208#if 0
    }
1210#endif
  } else {
    minR[i]=-1.0e60;
    maxR[i]=1.0e60;
1214#if 0
    markR[i]=-2;
    abort();
1217#else
    markR[i]=-1;
1219#endif
  }
}
1222}
1223#ifdef CGL_DEBUG
1224static int nPath=0;
1225#endif
1226//-------------------------------------------------------------------
1227// Generate disaggregation cuts
1228//------------------------------------------------------------------- 
1229void CglProbing::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
	      const CglTreeInfo info2)
1231{

1233#ifdef CGL_DEBUG
const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
if (debugger&&debugger->onOptimalPath(si)) {
  printf("On optimal path %d\n",nPath);
  nPath++;
  int nCols=si.getNumCols();
  int i;
  const double * solution = si.getColSolution();
  const double * lower = si.getColLower();
  const double * upper = si.getColUpper();
  const double * optimal = debugger->optimalSolution();
  const double * objective = si.getObjCoefficients();
  double objval1=0.0,objval2=0.0;
  for (i=0;i<nCols;i++) {
1247#if CGL_DEBUG>1
    printf("%d %g %g %g %g\n",i,lower[i],solution[i],upper[i],optimal[i]);
1249#endif
    objval1 += solution[i]*objective[i];
    objval2 += optimal[i]*objective[i];
    assert(optimal[i]>=lower[i]&&optimal[i]<=upper[i])(static_cast<void> (0));
  }
  printf("current obj %g, integer %g\n",objval1,objval2);
}
1256#endif
int saveRowCuts=rowCuts_;
if (rowCuts_<0) {
  if (info2.inTree)
    rowCuts_=4;
  else
    rowCuts_=-rowCuts_;
}
int nRows=si.getNumRows(); 
double * rowLower = new double[nRows+1];
double * rowUpper = new double[nRows+1];

int nCols=si.getNumCols();
// Set size if not set
if (!rowCopy_) {
  numberRows_=nRows;
  numberColumns_=nCols;
}
double * colLower = new double[nCols];
double * colUpper = new double[nCols];

CglTreeInfo info = info2;
int ninfeas=gutsOfGenerateCuts(si,cs,rowLower,rowUpper,colLower,colUpper,&info);
if (ninfeas) {
  // generate infeasible cut and return
  OsiRowCut rc;
  rc.setLb(COIN_DBL_MAX);
  rc.setUb(0.0);   
  cs.insert(rc);
1285#ifdef CGL_DEBUG
  const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
  if (debugger&&debugger->onOptimalPath(si))
    assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
1289#endif
}
delete [] rowLower;
delete [] rowUpper;
delete [] colLower;
delete [] colUpper;
delete [] colLower_;
delete [] colUpper_;
colLower_	= NULL__null;
colUpper_	= NULL__null;
rowCuts_=saveRowCuts;
1300}
1301int CglProbing::generateCutsAndModify(const OsiSolverInterface & si, 
		      OsiCuts & cs,
		      CglTreeInfo * info) 
1304{
1305#ifdef CGL_DEBUG
const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
if (debugger&&debugger->onOptimalPath(si)) {
  printf("On optimal path %d\n",nPath);
  nPath++;
  int nCols=si.getNumCols();
  int i;
  const double * solution = si.getColSolution();
  const double * lower = si.getColLower();
  const double * upper = si.getColUpper();
  const double * optimal = debugger->optimalSolution();
  const double * objective = si.getObjCoefficients();
  double objval1=0.0,objval2=0.0;
  for (i=0;i<nCols;i++) {
1319#if CGL_DEBUG>1
    printf("%d %g %g %g %g\n",i,lower[i],solution[i],upper[i],optimal[i]);
1321#endif
    objval1 += solution[i]*objective[i];
    objval2 += optimal[i]*objective[i];
    assert(optimal[i]>=lower[i]-1.0e-5&&optimal[i]<=upper[i]+1.0e-5)(static_cast<void> (0));
  }
  printf("current obj %g, integer %g\n",objval1,objval2);
}
1328#endif
int saveRowCuts=rowCuts_;
if (rowCuts_<0) {
  if (info->inTree)
    rowCuts_=4;
  else
    rowCuts_=-rowCuts_;
}
int saveMode = mode_;
bool rowCliques=false;
if (!mode_) {
  if (info->pass!=4||info->inTree) {
    mode_=1;
  } else {
    saveMode=1; // make sure do just once
    rowCliques=true;
  }
}
int nRows=si.getNumRows(); 
double * rowLower = new double[nRows+1];
double * rowUpper = new double[nRows+1];

int nCols=si.getNumCols(); 
double * colLower = new double[nCols];
double * colUpper = new double[nCols];

int ninfeas=gutsOfGenerateCuts(si,cs,rowLower,rowUpper,colLower,colUpper,info);
if (ninfeas) {
  // generate infeasible cut and return
  OsiRowCut rc;
  rc.setLb(COIN_DBL_MAX);
  rc.setUb(0.0);   
  cs.insert(rc);
1361#ifdef CGL_DEBUG
  const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
  if (debugger&&debugger->onOptimalPath(si))
    assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
1365#endif
}
rowCuts_=saveRowCuts;
mode_=saveMode;
// move bounds so can be used by user
if (mode_==3) {
  delete [] rowLower_;
  delete [] rowUpper_;
  rowLower_ = rowLower;
  rowUpper_ = rowUpper;
} else {
  delete [] rowLower;
  delete [] rowUpper;
}
delete [] colLower_;
delete [] colUpper_;
colLower_	= colLower;
colUpper_	= colUpper;
// Setup information 
if (rowCliques&&numberRows_&&numberColumns_)
  setupRowCliqueInformation(si);
return ninfeas;
1387}
1388bool analyze(const OsiSolverInterface * solverX, char * intVar,
           double * lower, double * upper)
1390{
OsiSolverInterface * solver = solverX->clone();
const double *objective = solver->getObjCoefficients() ;
int numberColumns = solver->getNumCols() ;
int numberRows = solver->getNumRows();
double direction = solver->getObjSense();
int iRow,iColumn;

// Row copy
CoinPackedMatrix matrixByRow(*solver->getMatrixByRow());
const double * elementByRow = matrixByRow.getElements();
const int * column = matrixByRow.getIndices();
const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
const int * rowLength = matrixByRow.getVectorLengths();

// Column copy
CoinPackedMatrix  matrixByCol(*solver->getMatrixByCol());
const double * element = matrixByCol.getElements();
const int * row = matrixByCol.getIndices();
const CoinBigIndex * columnStart = matrixByCol.getVectorStarts();
const int * columnLength = matrixByCol.getVectorLengths();

const double * rowLower = solver->getRowLower();
const double * rowUpper = solver->getRowUpper();

char * ignore = new char [numberRows];
int * which = new int[numberRows];
double * changeRhs = new double[numberRows];
memset(changeRhs,0,numberRows*sizeof(double));
memset(ignore,0,numberRows);
int numberChanged=0;
bool finished=false;
while (!finished) {
  int saveNumberChanged = numberChanged;
  for (iRow=0;iRow<numberRows;iRow++) {
    int numberContinuous=0;
    double value1=0.0,value2=0.0;
    bool allIntegerCoeff=true;
    double sumFixed=0.0;
    int jColumn1=-1,jColumn2=-1;
    for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
      int jColumn = column[j];
      double value = elementByRow[j];
      if (upper[jColumn] > lower[jColumn]+1.0e-8) {
        if (!intVar[jColumn]) {
          if (numberContinuous==0) {
            jColumn1=jColumn;
            value1=value;
          } else {
            jColumn2=jColumn;
            value2=value;
          }
          numberContinuous++;
        } else {
          if (fabs(value-floor(value+0.5))>1.0e-12)
            allIntegerCoeff=false;
        }
      } else {
        sumFixed += lower[jColumn]*value;
      }
    }
    double low = rowLower[iRow];
    if (low>-1.0e20) {
      low -= sumFixed;
      if (fabs(low-floor(low+0.5))>1.0e-12)
        allIntegerCoeff=false;
    }
    double up = rowUpper[iRow];
    if (up<1.0e20) {
      up -= sumFixed;
      if (fabs(up-floor(up+0.5))>1.0e-12)
        allIntegerCoeff=false;
    }
    if (!allIntegerCoeff)
      continue; // can't do
    if (numberContinuous==1) {
      // see if really integer
      // This does not allow for complicated cases
      if (low==up) {
        if (fabs(value1)>1.0e-3) {
          value1 = 1.0/value1;
          if (fabs(value1-floor(value1+0.5))<1.0e-12) {
            // integer
            numberChanged++;
            intVar[jColumn1]=77;
          }
        }
      } else {
        if (fabs(value1)>1.0e-3) {
          value1 = 1.0/value1;
          if (fabs(value1-floor(value1+0.5))<1.0e-12) {
            // This constraint will not stop it being integer
            ignore[iRow]=1;
          }
        }
      }
    } else if (numberContinuous==2) {
      if (low==up) {
        /* need general theory - for now just look at 2 cases -
           1 - +- 1 one in column and just costs i.e. matching objective
           2 - +- 1 two in column but feeds into G/L row which will try and minimize
           (take out 2 for now - until fixed)
        */
        if (fabs(value1)==1.0&&value1*value2==-1.0&&!lower[jColumn1]
            &&!lower[jColumn2]&&columnLength[jColumn1]==1&&columnLength[jColumn2]==1) {
          int n=0;
          int i;
          double objChange=direction*(objective[jColumn1]+objective[jColumn2]);
          double bound = CoinMin(upper[jColumn1],upper[jColumn2]);
          bound = CoinMin(bound,1.0e20);
          for ( i=columnStart[jColumn1];i<columnStart[jColumn1]+columnLength[jColumn1];i++) {
            int jRow = row[i];
            double value = element[i];
            if (jRow!=iRow) {
              which[n++]=jRow;
              changeRhs[jRow]=value;
            }
          }
          for ( i=columnStart[jColumn2];i<columnStart[jColumn2]+columnLength[jColumn2];i++) {
            int jRow = row[i];
            double value = element[i];
            if (jRow!=iRow) {
              if (!changeRhs[jRow]) {
                which[n++]=jRow;
                changeRhs[jRow]=value;
              } else {
                changeRhs[jRow]+=value;
              }
            }
          }
          if (objChange>=0.0) {
            // see if all rows OK
            bool good=true;
            for (i=0;i<n;i++) {
              int jRow = which[i];
              double value = changeRhs[jRow];
              if (value) {
                value *= bound;
                if (rowLength[jRow]==1) {
                  if (value>0.0) {
                    double rhs = rowLower[jRow];
                    if (rhs>0.0) {
                      double ratio =rhs/value;
                      if (fabs(ratio-floor(ratio+0.5))>1.0e-12)
                        good=false;
                    }
                  } else {
                    double rhs = rowUpper[jRow];
                    if (rhs<0.0) {
                      double ratio =rhs/value;
                      if (fabs(ratio-floor(ratio+0.5))>1.0e-12)
                        good=false;
                    }
                  }
                } else if (rowLength[jRow]==2) {
                  if (value>0.0) {
                    if (rowLower[jRow]>-1.0e20)
                      good=false;
                  } else {
                    if (rowUpper[jRow]<1.0e20)
                      good=false;
                  }
                } else {
                  good=false;
                }
              }
            }
            if (good) {
              // both can be integer
              numberChanged++;
              intVar[jColumn1]=77;
              numberChanged++;
              intVar[jColumn2]=77;
            }
          }
          // clear
          for (i=0;i<n;i++) {
            changeRhs[which[i]]=0.0;
          }
        }
      }
    }
  }
  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    if (upper[iColumn] > lower[iColumn]+1.0e-8&&!intVar[iColumn]) {
      double value;
      value = upper[iColumn];
      if (value<1.0e20&&fabs(value-floor(value+0.5))>1.0e-12) 
        continue;
      value = lower[iColumn];
      if (value>-1.0e20&&fabs(value-floor(value+0.5))>1.0e-12) 
        continue;
      bool integer=true;
      for (CoinBigIndex j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
        int iRow = row[j];
        if (!ignore[iRow]) {
          integer=false;
          break;
        }
      }
      if (integer) {
        // integer
        numberChanged++;
        intVar[iColumn]=77;
      }
    }
  }
  finished = numberChanged==saveNumberChanged;
}
bool feasible=true;
for (iColumn=0;iColumn<numberColumns;iColumn++) {
  if (intVar[iColumn]==77) {
    if (upper[iColumn]>1.0e20) {
      upper[iColumn] = 1.0e20;
    } else {
      upper[iColumn] = floor(upper[iColumn]+1.0e-5);
    }
    if (lower[iColumn]<-1.0e20) {
      lower[iColumn] = -1.0e20;
    } else {
      lower[iColumn] = ceil(lower[iColumn]-1.0e-5);
      if (lower[iColumn]>upper[iColumn])
        feasible=false;
    }
    if (lower[iColumn]==0.0&&upper[iColumn]==1.0)
      intVar[iColumn]=1;
    else if (lower[iColumn]==upper[iColumn])
      intVar[iColumn]=0;
    else
      intVar[iColumn]=2;
  }
}
delete [] which;
delete [] changeRhs;
delete [] ignore;
//if (numberChanged)
//printf("%d variables could be made integer\n",numberChanged);
delete solver;
return feasible;
1629}
1630int CglProbing::gutsOfGenerateCuts(const OsiSolverInterface & si, 
                                 OsiCuts & cs ,
                                 double * rowLower, double * rowUpper,
                                 double * colLower, double * colUpper,
                                 CglTreeInfo * info)
1635{
//printf("PASS\n");
// Get basic problem information
int nRows;

CoinPackedMatrix * rowCopy=NULL__null;
int numberRowCutsBefore = cs.sizeRowCuts();

// get branch and bound cutoff
double cutoff;
bool cutoff_available = si.getDblParam(OsiDualObjectiveLimit,cutoff);
if (!cutoff_available||usingObjective_<0) { // cut off isn't set or isn't valid
1
Assuming 'cutoff_available' is true→
2
←
Assuming field 'usingObjective_' is >= 0→
3
←
Taking false branch→
  cutoff = si.getInfinity();
}
cutoff *= si.getObjSense();
if (fabs(cutoff)>1.0e30)
4
←
Assuming the condition is false→
5
←
Taking false branch→
  assert (cutoff>1.0e30)(static_cast<void> (0));
int mode=mode_;

int nCols=si.getNumCols(); 

// get integer variables
const char * intVarOriginal = si.getColType(true);
char * intVar = CoinCopyOfArray(intVarOriginal,nCols);
int i;
int numberIntegers=0;
CoinMemcpyN(si.getColLower(),nCols,colLower);
CoinMemcpyN(si.getColUpper(),nCols,colUpper);
const double * colsol =si.getColSolution();
// and put reasonable bounds on integer variables
for (i=0;i<nCols;i++) {
6
←
Assuming 'i' is >= 'nCols'→
7
←
Loop condition is false. Execution continues on line 1677→
  if (intVar[i]) {
    numberIntegers++;
    if (intVar[i]==2) {
// make sure reasonable bounds
if (colsol[i]<1.0e10&&colUpper[i]>1.0e12) 
 colUpper[i] = CGL_REASONABLE_INTEGER_BOUND1.23456789e10;
if (colsol[i]>-1.0e10&&colLower[i]<-1.0e12) 
 colLower[i] = -CGL_REASONABLE_INTEGER_BOUND1.23456789e10;
    }
  }
}
bool feasible=true;
if (!info->inTree&&!info->pass) {
8
←
Assuming field 'inTree' is true→
  // make more integer
  feasible = analyze(&si,intVar,colLower,colUpper);
}
if (feasible8.1
'feasible' is true
1
'feasible' is true
1
'feasible' is true
&&PROBING_EXTRA_STUFFfalse) {
9
←
Taking false branch→
  // tighten bounds on djs
  // should be in CbcCutGenerator and check if basic 
  const double * djs =si.getReducedCost();
  const double * colsol =si.getColSolution();
  double direction = si.getObjSense();
  double cutoff;
  bool cutoff_available = si.getDblParam(OsiDualObjectiveLimit,cutoff);
  if (!cutoff_available||usingObjective_<0) { // cut off isn't set or isn't valid
    cutoff = si.getInfinity();
  }
  cutoff *= direction;
  if (fabs(cutoff)>1.0e30)
    assert (cutoff>1.0e30)(static_cast<void> (0));
  double current = si.getObjValue();
  current *= direction;
  double gap=CoinMax(cutoff-current,1.0e-1);
  for (int i = 0; i < nCols; ++i) {
    double djValue = djs[i]*direction;
    if (colUpper[i]-colLower[i]>1.0e-8) {
      if (colsol[i]<colLower[i]+primalTolerance_) {
        if (djValue>gap) {
          if (si.isInteger(i)) {
            printf("why int %d not fixed at lb\n",i);
            colUpper[i]= colLower[i];
          } else {
            double newUpper = colLower[i] + gap/djValue;
            if (newUpper<colUpper[i]) {
              //printf("%d ub from %g to %g\n",i,colUpper[i],newUpper);
              colUpper[i]= CoinMax(newUpper,colLower[i]+1.0e-5);
            }
          }
        }
      } else if (colsol[i]>colUpper[i]-primalTolerance_) {
        if (-djValue>gap) {
          if (si.isInteger(i)) {
            printf("why int %d not fixed at ub\n",i);
            colLower[i]= colUpper[i];
          } else {
            double newLower = colUpper[i] + gap/djValue;
            if (newLower>colLower[i]) {
              //printf("%d lb from %g to %g\n",i,colLower[i],newLower);
              colLower[i]= CoinMin(newLower,colUpper[i]-1.0e-5);
            }
          }
        }
      }
    }
  }
}
int ninfeas=0;
// Set up maxes
int maxProbe = info->inTree9.1
Field 'inTree' is true
1
Field 'inTree' is true
1
Field 'inTree' is true
 ? maxProbe_ : maxProbeRoot_;
10
←
'?' condition is true→
int maxElements = info->inTree10.1
Field 'inTree' is true
1
Field 'inTree' is true
1
Field 'inTree' is true
 ? maxElements_ : maxElementsRoot_;
11
←
'?' condition is true→
//if (!info->inTree&&!info->pass)
//maxElements=nCols;
// Get objective offset
double offset;
si.getDblParam(OsiObjOffset,offset);
1741#ifdef COIN_DEVELOP
if (offset&&!info->inTree&&!info->pass) 
  printf("CglProbing obj offset %g\n",offset);
1744#endif
// see if using cached copy or not
if (!rowCopy_) {
12
←
Assuming field 'rowCopy_' is non-null→
13
←
Taking false branch→
  // create from current
  nRows=si.getNumRows(); 
  
  // mode==0 is invalid if going from current matrix
  if (mode==0)
    mode=1;
  // add in objective if there is a cutoff
  if (cutoff<1.0e30&&usingObjective_>0) {
    rowCopy = new CoinPackedMatrix(*si.getMatrixByRow(),1,nCols,false);
  } else {
    rowCopy = new CoinPackedMatrix(*si.getMatrixByRow());
  }
  // add in objective if there is a cutoff
  if (cutoff<1.0e30&&usingObjective_>0) {
    int * columns = new int[nCols];
    double * elements = new double[nCols];
    int n=0;
    const double * objective = si.getObjCoefficients();
    bool maximize = (si.getObjSense()==-1);
    for (i=0;i<nCols;i++) {
if (objective[i]) {
 elements[n]= (maximize) ? -objective[i] : objective[i];
 columns[n++]=i;
}
    }
    rowCopy->appendRow(n,columns,elements);
    delete [] columns;
    delete [] elements;
    CoinMemcpyN(si.getRowLower(),nRows,rowLower);
    CoinMemcpyN(si.getRowUpper(),nRows,rowUpper);
    rowLower[nRows]=-COIN_DBL_MAX;
    rowUpper[nRows]=cutoff+offset;
    nRows++;
  } else {
    CoinMemcpyN(si.getRowLower(),nRows,rowLower);
    CoinMemcpyN(si.getRowUpper(),nRows,rowUpper);
  }
} else {
  // use snapshot
  nRows=numberRows_;
  assert(nCols==numberColumns_)(static_cast<void> (0));
  
  rowCopy = new CoinPackedMatrix(*rowCopy_);
  assert (rowCopy_->getNumRows()==numberRows_)(static_cast<void> (0));
  rowLower = new double[nRows];
  rowUpper = new double[nRows];
  CoinMemcpyN(rowLower_,nRows,rowLower);
  CoinMemcpyN(rowUpper_,nRows,rowUpper);
  if (usingObjective_>0) {
14
←
Assuming field 'usingObjective_' is <= 0→
15
←
Taking false branch→
    rowLower[nRows-1]=-COIN_DBL_MAX;
    rowUpper[nRows-1]=cutoff+offset;
  }
}
CoinBigIndex * rowStartPos = NULL__null;
int * realRows = NULL__null;
{
  // Now take out rows with too many elements
  int * rowLength = rowCopy->getMutableVectorLengths(); 
  //#define OUTRUBBISH
  double * elements = rowCopy->getMutableElements();
  int * column = rowCopy->getMutableIndices();
  CoinBigIndex * rowStart = rowCopy->getMutableVectorStarts();
1809#ifdef OUTRUBBISH
  double large=1.0e3;
1811#endif
  int nDelete = 0;
  int nKeep=0;
  int * which = new int[nRows];
  int nElements=rowCopy->getNumElements();
  int nTotalOut=0;
  int nRealRows = si.getNumRows();
  for (i=0;i<nRows;i++) {
16
←
Assuming 'i' is >= 'nRows'→
17
←
Loop condition is false. Execution continues on line 1826→
    if (rowLength[i]>maxElements||(rowLower[i]<-1.0e20&&rowUpper[i]>1.0e20)) {
// keep objective
if (i<nRealRows) 
 nTotalOut+=rowLength[i];
    }
  }
  // keep all if only a few dense
  if (nTotalOut*10<nElements)
18
←
Assuming the condition is false→
19
←
Taking false branch→
    maxElements=nCols;
1828#ifdef OUTRUBBISH
  int nExtraDel=0;
1830#endif
  for (i=0;i19.1
'i' is >= 'nRows'
1
'i' is >= 'nRows'
1
'i' is >= 'nRows'
<nRows;i++) {
20
←
Loop condition is false. Execution continues on line 1946→
    if ((rowLength[i]>maxElements&&i<nRealRows)||
 (rowLower[i]<-1.0e20&&rowUpper[i]>1.0e20)) {
which[nDelete++]=i;
    } else {
1836#ifdef OUTRUBBISH
// out all rows with infinite plus and minus
int nPlus=rowUpper[i]>-large ? 0 : 1;
int nMinus=rowLower[i]<large ? 0 : 1;
CoinBigIndex start = rowStart[i];
CoinBigIndex end = start + rowLength[i];
for (CoinBigIndex j=start; j<end ; j++) { 
 int iColumn = column[j];
 if (colUpper[iColumn]>large) {
   if (elements[j]>0.0)
     nPlus++;
   else
     nMinus++;
 }
 if (colLower[iColumn]<-large) {
   if (elements[j]<0.0)
     nPlus++;
   else
     nMinus++;
 }
}
if (!nPlus||!nMinus) {
 rowLower[nKeep]=rowLower[i];
 rowUpper[nKeep]=rowUpper[i];
 nKeep++;
} else {
 nExtraDel++;
 which[nDelete++]=i;
}
1865#else
if (info->strengthenRow&&!info->pass&&(rowLower[i]<-1.0e20||rowUpper[i]>1.0e20)) {
 int nPlus=0;
 int nMinus=0;
 for (CoinBigIndex j=rowStart[i];j<rowStart[i+1];j++) {
   int jColumn=column[j];
   if (intVar[jColumn]&&colLower[jColumn]==0.0&&colUpper[jColumn]==1.0) {
     double value=elements[j];
     if (value>0.0) {
nPlus++;
     } else {
nMinus++;
     }
   } else {
     nPlus=2;
     nMinus=2;
     break;
   }
 }
 double effectiveness=0.0;
 if (nPlus==1&&rowUpper[i]>0.0&&rowUpper[i]<1.0e10) {
   // can make element smaller
   for (CoinBigIndex j=rowStart[i];j<rowStart[i+1];j++) {
     double value=elements[j];
     if (value>0.0) {
elements[j] -= rowUpper[i];
//printf("pass %d row %d plus el from %g to %g\n",info->pass,
//     i,elements[j]+rowUpper[i],elements[j]);
     }
     effectiveness += fabs(elements[j]);
   }
   rowUpper[i]=0.0;
 } else if (nMinus==1&&rowLower[i]<0.0&&rowLower[i]>-1.0e10) {
   // can make element smaller in magnitude
   for (CoinBigIndex j=rowStart[i];j<rowStart[i+1];j++) {
     double value=elements[j];
     if (value<0.0) {
elements[j] -= rowLower[i];
//printf("pass %d row %d minus el from %g to %g\n",info->pass,
//     i,elements[j]+rowLower[i],elements[j]);
     }
     effectiveness += fabs(elements[j]);
   }
   rowLower[i]=0.0;
 }
 if (effectiveness) {
   OsiRowCut rc;
   rc.setLb(rowLower[i]);
   rc.setUb(rowUpper[i]);
   int start = rowStart[i];
   int n = rowLength[i];
   rc.setRow(rowLength[i],column+start,elements+start,false);
   // but get rid of tinies
   CoinPackedVector & row = rc.mutableRow();
   double * elements = row.getElements();
   int n2=0;
   for (n2=0;n2<n;n2++) {
     if (fabs(elements[n2])<1.0e-12)
break;
   }
   if (n2<n) {
     int * columns = row.getIndices();
     for (int i=n2+1;i<n;i++) {
if (fabs(elements[i])>1.0e-12) {
  elements[n2]=elements[i];
  columns[n2++]=columns[i];
}
     }
     row.truncate(n2);
   }
   rc.setEffectiveness(effectiveness);
   assert (!info->strengthenRow[i])(static_cast<void> (0));
   info->strengthenRow[i]=rc.clone();
 }
}
rowLower[nKeep]=rowLower[i];
rowUpper[nKeep]=rowUpper[i];
nKeep++;
1943#endif
    }
  }
  if (nDelete20.1
'nDelete' is 0
1
'nDelete' is 0
1
'nDelete' is 0
) {
21
←
Taking false branch→
1947#ifdef OUTRUBBISH
    if (nExtraDel) {
printf("%d rows deleted (extra %d)\n",nDelete,nExtraDel);
    }
1951#else
1952#endif
    if (info->strengthenRow) {
// Set up pointers to real rows
realRows = new int [nRows];
CoinZeroN(realRows,nRows);
for (i=0;i<nDelete;i++)
 realRows[which[i]]=-1;
int k=0;
for (i=0;i<nRows;i++) {
 if (!realRows[i]) {
   if (i<nRealRows)
     realRows[k++]=i; // keep
   else
     realRows[k++]=-1; // objective - discard
 }
}
    }
    rowCopy->deleteRows(nDelete,which);
    nRows=nKeep;
  }
  delete [] which;
  if (!nRows21.1
'nRows' is not equal to 0
1
'nRows' is not equal to 0
1
'nRows' is not equal to 0
) {
22
←
Taking false branch→
1974#ifdef COIN_DEVELOP
    printf("All rows too long for probing\n");
1976#endif
    // nothing left!!
    // delete stuff
    delete rowCopy;
    if (rowCopy_) {
delete [] rowLower;
delete [] rowUpper;
    }
    delete [] intVar;
    // and put back unreasonable bounds on integer variables
    const double * trueLower = si.getColLower();
    const double * trueUpper = si.getColUpper();
    for (i=0;i<nCols;i++) {
if (intVarOriginal[i]==2) {
 if (colUpper[i] == CGL_REASONABLE_INTEGER_BOUND1.23456789e10) 
   colUpper[i] = trueUpper[i];
 if (colLower[i] == -CGL_REASONABLE_INTEGER_BOUND1.23456789e10) 
   colLower[i] = trueLower[i];
}
    }
    delete [] realRows;
    return 0;
  }
  // Out elements for fixed columns and sort
  elements = rowCopy->getMutableElements();
  column = rowCopy->getMutableIndices();
  rowStart = rowCopy->getMutableVectorStarts();
  rowLength = rowCopy->getMutableVectorLengths(); 
2004#if 0
  int nFixed=0;
  for (i=0;i<nCols;i++) {
    if (colUpper[i]==colLower[i])
nFixed++;
  }
  printf("%d columns fixed\n",nFixed);
2011#endif
  CoinBigIndex newSize=0;
  int * column2 = new int[nCols];
  double * elements2 = new double[nCols];
  rowStartPos = new CoinBigIndex [nRows];
  for (i=0;i22.1
'i' is >= 'nRows'
1
'i' is >= 'nRows'
1
'i' is >= 'nRows'
<nRows;i++) {
23
←
Loop condition is false. Execution continues on line 2051→
    double offset = 0.0;
    CoinBigIndex start = rowStart[i];
    rowStart[i]=newSize;
    CoinBigIndex save=newSize;
    CoinBigIndex end = start + rowLength[i];
    int nOther=0;
    for (CoinBigIndex j=start; j<end ; j++) { 
int iColumn = column[j];
if (colUpper[iColumn]>colLower[iColumn]) {
 double value = elements[j];
 if (value<0.0) {
   elements[newSize]=value;
   column[newSize++]=iColumn;
 } else if (value>0.0) {
   elements2[nOther]=value;
   column2[nOther++]=iColumn;
 }
} else {
 offset += colUpper[iColumn]*elements[j];
}
    }
    rowStartPos[i] = newSize;
    for (int k=0;k<nOther;k++) {
elements[newSize]=elements2[k];
column[newSize++]=column2[k];
    }
    rowLength[i]=newSize-save;
    if (offset) {
if (rowLower[i]>-1.0e20)
 rowLower[i] -= offset;
if (rowUpper[i]<1.0e20)
 rowUpper[i] -= offset;
    }
  }
  delete [] column2;
  delete [] elements2;
  rowStart[nRows]=newSize;
  rowCopy->setNumElements(newSize);
}
CoinPackedMatrix * columnCopy=new CoinPackedMatrix(*rowCopy,0,0,true);
int nRowsSafe=CoinMin(nRows,si.getNumRows());
2058#ifdef CGL_DEBUG
const OsiRowCutDebugger * debugger = si.getRowCutDebugger();
if (debugger&&!debugger->onOptimalPath(si))
  debugger = NULL__null;
2062#else
const OsiRowCutDebugger * debugger = NULL__null;
2064#endif
 
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths(); 
const double * rowElements = rowCopy->getElements();
// Arrays so user can find out what happened
if (!lookedAt_) {
24
←
Assuming field 'lookedAt_' is non-null→
25
←
Taking false branch→
  lookedAt_ = new int[nCols];
}
numberThisTime_=0;
// Let us never add more than twice the number of rows worth of row cuts
// Keep cuts out of cs until end so we can find duplicates quickly
int nRowsFake = info->inTree25.1
Field 'inTree' is true
1
Field 'inTree' is true
1
Field 'inTree' is true
 ? nRowsSafe/3 : nRowsSafe;
26
←
'?' condition is true→
if (!info->inTree26.1
Field 'inTree' is true
1
Field 'inTree' is true
1
Field 'inTree' is true
&&!info->pass) 
  nRowsFake *= 5;
row_cut rowCut(nRowsFake,!info->inTree);
int * markR = new int [nRows];
double * minR = new double [nRows];
double * maxR = new double [nRows];
if (mode) {
27
←
Assuming 'mode' is 0→
28
←
Taking false branch→
  ninfeas= tighten(colLower, colUpper, column, rowElements,
     rowStart, rowStartPos ,rowLength, rowLower, rowUpper,
     nRows, nCols, intVar, 2, primalTolerance_);
  if (!feasible)
    ninfeas=1;
  if (!ninfeas) {
    // create column cuts where integer bounds have changed
    {
const double * lower = si.getColLower();
const double * upper = si.getColUpper();
const double * colsol = si.getColSolution();
int numberChanged=0,ifCut=0;
CoinPackedVector lbs;
CoinPackedVector ubs;
for (i = 0; i < nCols; ++i) {
 if (intVar[i]) {
   colUpper[i] = CoinMin(upper[i],floor(colUpper[i]+1.0e-4));
   if (colUpper[i]<upper[i]-1.0e-8) {
     if (colUpper[i]<colsol[i]-1.0e-8)
ifCut=1;
     ubs.insert(i,colUpper[i]);
     numberChanged++;
   }
   colLower[i] = CoinMax(lower[i],ceil(colLower[i]-1.0e-4));
   if (colLower[i]>lower[i]+1.0e-8) {
     if (colLower[i]>colsol[i]+1.0e-8)
ifCut=1;
     lbs.insert(i,colLower[i]);
     numberChanged++;
   }
 }
}
if (numberChanged) {
 OsiColCut cc;
 cc.setUbs(ubs);
 cc.setLbs(lbs);
 if (ifCut) {
   cc.setEffectiveness(100.0);
 } else {
   cc.setEffectiveness(1.0e-5);
 }
2126#ifdef CGL_DEBUG
 checkBounds(debugger,cc);
2128#endif
 cs.insert(cc);
}
    }
    if (maxProbe>0) {
      numberThisTime_=0;
      // get min max etc for rows
      tighten2(colLower, colUpper, column, rowElements,
               rowStart, rowLength, rowLower, rowUpper,
               minR , maxR , markR, nRows);
      // decide what to look at
      if (mode==1) {
        const double * colsol = si.getColSolution();
        double_int_pair * array = new double_int_pair [nCols];
2142#	  ifdef ZEROFAULT
 std::memset(array,0,sizeof(double_int_pair)*nCols) ;
2144#	  endif
 double multiplier = -1.0;
 if (info->inTree||(info->pass&1)!=0)
   multiplier=1.0;
 //const int * columnLength = si.getMatrixByCol()->getVectorLengths();
        for (i=0;i<nCols;i++) {
          if (intVar[i]&&colUpper[i]-colLower[i]>1.0e-8) {
            double away = fabs(0.5-(colsol[i]-floor(colsol[i])));
            if (away<0.49999||!info->inTree) {
              //array[numberThisTime_].infeasibility=away;
              array[numberThisTime_].infeasibility=away*multiplier;
              //array[numberThisTime_].infeasibility=-columnLength[i];
              array[numberThisTime_++].sequence=i;
            }
          }
        }
 //printf("maxP %d num %d\n",maxProbe,numberThisTime_);
        std::sort(array,array+numberThisTime_,double_int_pair_compare());
        //numberThisTime_=CoinMin(numberThisTime_,maxProbe);
        for (i=0;i<numberThisTime_;i++) {
          lookedAt_[i]=array[i].sequence;
        }
        delete [] array;
      } else {
        for (i=0;i<nCols;i++) {
          if (intVar[i]&&colUpper[i]-colLower[i]>1.0e-8) {
            lookedAt_[numberThisTime_++]=i;
          }
        }
      }
2174#if 0
      // Only look at short rows
      for (i=0;i<nRows;i++) {
        if (rowLength[i]>maxElements)
          abort(); //markR[i]=-2;
      }
2180#endif
// sort to be clean
//std::sort(lookedAt_,lookedAt_+numberThisTime_);
      if (!numberCliques_) {
        ninfeas= probe(si, debugger, cs, colLower, colUpper, rowCopy,columnCopy,
                       rowStartPos, realRows, rowLower, rowUpper,
                       intVar, minR, maxR, markR,
                       info);
      } else {
        ninfeas= probeCliques(si, debugger, cs, colLower, colUpper, rowCopy,columnCopy,
                              realRows,rowLower, rowUpper,
                              intVar, minR, maxR, markR,
                              info);
      }
    }
  }
} else if (maxProbe>0) {
29
←
Assuming 'maxProbe' is > 0→
30
←
Taking true branch→
  // global cuts from previous calculations
  // could check more thoroughly that integers are correct
  assert(numberIntegers==numberIntegers_)(static_cast<void> (0));
  // make up list of new variables to look at 
  numberThisTime_=0;
  const double * colsol = si.getColSolution();
  double_int_pair * array = new double_int_pair [nCols];
2204#   ifdef ZEROFAULT
  std::memset(array,0,sizeof(double_int_pair)*nCols) ;
2206#   endif
  for (i=0;i<number01Integers_;i++) {
31
←
Assuming 'i' is >= field 'number01Integers_'→
32
←
Loop condition is false. Execution continues on line 2215→
    int j=cutVector_[i].sequence;
    if (!cutVector_[i].index&&colUpper[j]-colLower[j]>1.0e-8) {
double away = fabs(0.5-(colsol[j]-floor(colsol[j])));
      array[numberThisTime_].infeasibility=away;
      array[numberThisTime_++].sequence=i;
    }
  }
  std::sort(array,array+numberThisTime_,double_int_pair_compare());
  numberThisTime_=CoinMin(numberThisTime_,maxProbe);
  for (i=0;i<numberThisTime_;i++) {
33
←
Loop condition is false. Execution continues on line 2222→
    lookedAt_[i]=array[i].sequence;
  }
  // sort to be clean
  //std::sort(lookedAt_,lookedAt_+numberThisTime_);
  delete [] array;
  // get min max etc for rows
  tighten2(colLower, colUpper, column, rowElements,
    rowStart, rowLength, rowLower, rowUpper,
    minR , maxR , markR, nRows);
  OsiCuts csNew;
  // don't do cuts at all if 0 (i.e. we are just checking bounds)
  if (rowCuts_) {
34
←
Assuming field 'rowCuts_' is not equal to 0→
35
←
Taking true branch→
2230#if 0
    // Only look at short rows
    for (i=0;i<nRows;i++) {
      if (rowLength[i]>maxElements)
        abort(); //markR[i]=-2;
    }
2236#endif
    ninfeas= probeCliques(si, debugger, csNew, colLower, colUpper, rowCopy,columnCopy,
	    realRows, rowLower, rowUpper,
     intVar, minR, maxR, markR,
     info);
  }
  if (!ninfeas) {
36
←
Assuming 'ninfeas' is 0→
37
←
Taking true branch→
    // go through row cuts
    int nCuts = csNew.sizeRowCuts();
    int iCut;
    // need space for backward lookup
    // just for ones being looked at
    int * backward = new int [2*nCols];
    int * onList = backward + nCols;
    for (i=0;i37.1
'i' is >= 'nCols'
1
'i' is >= 'nCols'
1
'i' is >= 'nCols'
<nCols;i++) {
38
←
Loop condition is false. Execution continues on line 2254→
      backward[i]=-1;
      onList[i]=0;
    }
    for (i=0;i<number01Integers_;i++) {
39
←
Assuming 'i' is < field 'number01Integers_'→
40
←
Loop condition is true.  Entering loop body→
41
←
Assuming 'i' is >= field 'number01Integers_'→
42
←
Loop condition is false. Execution continues on line 2261→
int j=cutVector_[i].sequence;
backward[j]=i;
onList[j]=1;
    }
    // first do counts
    // we know initialized to zero
    for (iCut=0;iCut<nCuts;iCut++) {
43
←
Assuming 'iCut' is >= 'nCuts'→
44
←
Loop condition is false. Execution continues on line 2353→
OsiRowCut rcut;
CoinPackedVector rpv;
rcut = csNew.rowCut(iCut);
rpv = rcut.row();
assert(rpv.getNumElements()==2)(static_cast<void> (0));
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double lb=rcut.lb();
// find out which integer
      int which=0;
      i=backward[indices[0]];
      if (i<0||!onList[indices[0]]) {
        which=1;
        i=backward[indices[1]];
        // Just possible variable was general integer but now 0-1
        if (!onList[indices[which]])
          continue;
      }
      int other = indices[1-which];
if (lb==-COIN_DBL_MAX) {
        if (!rcut.ub()) {
          // UB
          if (elements[which]<0.0) {
            //assert (elements[1-which]>0.0);
            // delta to 0 => x to 0.0
            cutVector_[i].length++;
          } else {
            if (elements[1-which]<0.0&&fabs(elements[which]/elements[1-which]-
                                            colUpper[other])<1.0e-5) {
              // delta to 1 => x to upper bound
              cutVector_[i].length++;
            } else {
              if (onList[other]) {
                double value0 = elements[0];
                double value1 = elements[1];
                if (value0*value1==-1.0) {
                  // can do something ?
                  int j=backward[other];
                  cutVector_[i].length++;
                  cutVector_[j].length++;
                } else {
                  continue;
                }
              }
            }
          }
        } else {
          if (onList[other]) {
            if (elements[0]==1.0&&elements[1]==1.0&&rcut.ub()==1.0) {
              // can do something ?
              int j=backward[other];
              cutVector_[i].length++;
              cutVector_[j].length++;
            } else {
              continue;
            }
          }
        }
} else {
        assert(rcut.ub()==DBL_MAX)(static_cast<void> (0));
        if (!lb) {
          // LB
          if (elements[which]>0.0) {
            //assert (elements[1-which]<0.0);
            // delta to 0 => x to 0.0
            // flip so same as UB
            cutVector_[i].length++; 
          } else {
            if (elements[1-which]<0.0&&fabs(elements[which]/elements[1-which]-
                                            colUpper[other])<1.0e-5) {
              // delta to 1 => x to upper bound
              cutVector_[i].length++;
            } else {
              if (onList[other]) {
                double value0 = elements[0];
                double value1 = elements[1];
                if (value0*value1==-1.0) {
                  // can do something ?
                  int j=backward[other];
                  cutVector_[i].length++;
                  cutVector_[j].length++;
                } else {
                  continue;
                }
              }
            }
          }
        }
} 
    }
    // allocate space
    for (i=0;i<number01Integers_;i++) {
45
←
Loop condition is true.  Entering loop body→
47
←
Loop condition is false. Execution continues on line 2362→
int j=cutVector_[i].sequence;
if (onList[j]&&!cutVector_[i].index) {
46
←
Assuming the condition is false→
 disaggregation thisOne=cutVector_[i];
 cutVector_[i].index=new disaggregationAction [thisOne.length];
        cutVector_[i].length=0;
}
    }
    // now put in
    for (iCut=0;iCut47.1
'iCut' is >= 'nCuts'
1
'iCut' is >= 'nCuts'
1
'iCut' is >= 'nCuts'
<nCuts;iCut++) {
48
←
Loop condition is false. Execution continues on line 2532→
OsiRowCut rcut;
CoinPackedVector rpv;
int iput;
rcut = csNew.rowCut(iCut);
rpv = rcut.row();
assert(rpv.getNumElements()==2)(static_cast<void> (0));
const int * indices = rpv.getIndices();
double* elements = rpv.getElements();
double lb=rcut.lb();
// find out which integer
// find out which integer
      int which=0;
      i=backward[indices[0]];
      if (i<0||!onList[indices[0]]) {
        which=1;
        i=backward[indices[1]];
        // Just possible variable was general integer but now 0-1
        if (!onList[indices[which]])
          continue;
      }
      int other = indices[1-which];
      int j = other ? backward[other] : -1;
if (lb==-COIN_DBL_MAX) {
        if (!rcut.ub()) {
          // UB
          if (elements[which]<0.0) {
            iput=cutVector_[i].length;
            if (j>=0)
              setAffectedInDisaggregation(cutVector_[i].index[iput],j);
            else
              setAffectedInDisaggregation(cutVector_[i].index[iput],other);
            setWhenAtUBInDisaggregation(cutVector_[i].index[iput],false);
            setAffectedToUBInDisaggregation(cutVector_[i].index[iput],false);
     setZeroOneInDisaggregation(cutVector_[i].index[iput],onList[other]!=0);
            cutVector_[i].length++;
          } else { 
            if (elements[1-which]<0.0&&fabs(elements[which]/elements[1-which]-
                                            colUpper[other])<1.0e-5) {
              // delta to 1 => x to upper bound
              iput=cutVector_[i].length;
              if (j>=0)
                setAffectedInDisaggregation(cutVector_[i].index[iput],j);
              else
                setAffectedInDisaggregation(cutVector_[i].index[iput],other);
              setWhenAtUBInDisaggregation(cutVector_[i].index[iput],true);
              setAffectedToUBInDisaggregation(cutVector_[i].index[iput],true);
              setZeroOneInDisaggregation(cutVector_[i].index[iput],onList[other]!=0);
              cutVector_[i].length++;
            } else {
              if (onList[other]) {
                double value0 = elements[0];
                double value1 = elements[1];
                if (value0*value1==-1.0) {
                  // can do something ?
                  int j=backward[other];
                  assert (j>=0)(static_cast<void> (0));
                  // flip so value0 1.0
                  if (value1==1.0) {
                    j=i;
                    i=backward[other];
                    value1=value0;
                    value0=1.0;
                  }
                  assert (value0==1.0)(static_cast<void> (0));
                  assert (value1==-1.0)(static_cast<void> (0));
                  iput=cutVector_[i].length;
                  setAffectedInDisaggregation(cutVector_[i].index[iput],j);
                  setWhenAtUBInDisaggregation(cutVector_[i].index[iput],true);
                  setAffectedToUBInDisaggregation(cutVector_[i].index[iput],true);
                  setZeroOneInDisaggregation(cutVector_[i].index[iput],true);
                  cutVector_[i].length++;
                  iput=cutVector_[j].length;
                  setAffectedInDisaggregation(cutVector_[j].index[iput],i);
                  setWhenAtUBInDisaggregation(cutVector_[j].index[iput],false);
                  setAffectedToUBInDisaggregation(cutVector_[j].index[iput],false);
                  setZeroOneInDisaggregation(cutVector_[j].index[iput],true);
                  cutVector_[j].length++;
                }
              }
            }
          }
        } else {
          if (onList[other]) {
            if (elements[0]==1.0&&elements[1]==1.0&&rcut.ub()==1.0) {
              // can do something ?
              int j=backward[other];
              assert (j>=0)(static_cast<void> (0));
              iput=cutVector_[i].length;
              setAffectedInDisaggregation(cutVector_[i].index[iput],j);
              setWhenAtUBInDisaggregation(cutVector_[i].index[iput],true);
              setAffectedToUBInDisaggregation(cutVector_[i].index[iput],false);
              setZeroOneInDisaggregation(cutVector_[i].index[iput],true);
              cutVector_[i].length++;
              iput=cutVector_[j].length;
              setAffectedInDisaggregation(cutVector_[j].index[iput],i);
              setWhenAtUBInDisaggregation(cutVector_[j].index[iput],true);
              setAffectedToUBInDisaggregation(cutVector_[j].index[iput],false);
              setZeroOneInDisaggregation(cutVector_[j].index[iput],true);
              cutVector_[j].length++;
            } else {
2463#ifdef COIN_DEVELOP
              abort();
2465#endif
continue;
            }
          }
        }
} else {
        assert(rcut.ub()==DBL_MAX)(static_cast<void> (0));
        if (!lb) {
          // LB
          if (elements[which]>0.0) {
            iput=cutVector_[i].length;
            if (j>=0)
              setAffectedInDisaggregation(cutVector_[i].index[iput],j);
            else
              setAffectedInDisaggregation(cutVector_[i].index[iput],other);
            setWhenAtUBInDisaggregation(cutVector_[i].index[iput],false);
            setAffectedToUBInDisaggregation(cutVector_[i].index[iput],false);
            setZeroOneInDisaggregation(cutVector_[i].index[iput],onList[other]!=0);
            cutVector_[i].length++;
          } else { 
            if (elements[1-which]<0.0&&fabs(elements[which]/elements[1-which]-
                                            colUpper[other])<1.0e-5) {
              iput=cutVector_[i].length;
              if (j>=0)
                setAffectedInDisaggregation(cutVector_[i].index[iput],j);
              else
                setAffectedInDisaggregation(cutVector_[i].index[iput],other);
              setWhenAtUBInDisaggregation(cutVector_[i].index[iput],true);
              setAffectedToUBInDisaggregation(cutVector_[i].index[iput],true);
              setZeroOneInDisaggregation(cutVector_[i].index[iput],onList[other]!=0);
              cutVector_[i].length++;
            } else {
              if (onList[other]) {
                double value0 = elements[0];
                double value1 = elements[1];
                if (value0*value1==-1.0) {
                  // can do something ?
                  int j=backward[other];
                  assert (j>=0)(static_cast<void> (0));
                  // flip so value0 -1.0
                  if (value1==-1.0) {
                    j=i;
                    i=backward[other];
                    value1=value0;
                    value0=-1.0;
                  }
                  assert (value0==-1.0)(static_cast<void> (0));
                  assert (value1==1.0)(static_cast<void> (0));
                  iput=cutVector_[i].length;
                  setAffectedInDisaggregation(cutVector_[i].index[iput],j);
                  setWhenAtUBInDisaggregation(cutVector_[i].index[iput],true);
                  setAffectedToUBInDisaggregation(cutVector_[i].index[iput],true);
                  setZeroOneInDisaggregation(cutVector_[i].index[iput],true);
                  cutVector_[i].length++;
                  iput=cutVector_[j].length;
                  setAffectedInDisaggregation(cutVector_[j].index[iput],i);
                  setWhenAtUBInDisaggregation(cutVector_[j].index[iput],false);
                  setAffectedToUBInDisaggregation(cutVector_[j].index[iput],false);
                  setZeroOneInDisaggregation(cutVector_[j].index[iput],true);
                  cutVector_[j].length++;
                }
              }
            }
          }
        }
} 
    }
    delete [] backward;
    // Now sort and get rid of duplicates
    // could also see if any are cliques
    int longest=0;
    for (i=0;i<number01Integers_;i++) 
49
←
Loop condition is true.  Entering loop body→
50
←
Loop condition is false. Execution continues on line 2538→
      longest = CoinMax(longest, cutVector_[i].length);
    unsigned int * sortit = new unsigned int[longest];
51
←
Memory is allocated→
    for (i=0;i<number01Integers_;i++) {
52
←
Loop condition is true.  Entering loop body→
      disaggregation & thisOne=cutVector_[i];
      int k;
      int number = thisOne.length;
      for (k=0;k52.1
'k' is >= 'number'
1
'k' is >= 'number'
1
'k' is >= 'number'
<number;k++) {
53
←
Loop condition is false. Execution continues on line 2550→
        int affected = affectedInDisaggregation(thisOne.index[k]);
        int zeroOne = zeroOneInDisaggregation(thisOne.index[k]) ? 1 : 0;
        int whenAtUB = whenAtUBInDisaggregation(thisOne.index[k]) ? 1 : 0;
        int affectedToUB = affectedToUBInDisaggregation(thisOne.index[k]) ? 1: 0;
        sortit[k]=(affected<<3)|(zeroOne<<2)|(whenAtUB<<1)|affectedToUB;
      }
      std::sort(sortit,sortit+number);
54
←
Calling 'sort<unsigned int *>'→
      int affectedLast = 0xffffffff;
      int zeroOneLast = 0;
      int whenAtUBLast = 0;
      int affectedToUBLast = 0; 
      int put=0;
      for (k=0;k<number;k++) {
        int affected = sortit[k]>>3;
        int zeroOne = (sortit[k]&4)>>2;
        int whenAtUB = (sortit[k]&2)>>1;
        int affectedToUB = sortit[k]&1;
        disaggregationAction action;
 action.affected=0;
        setAffectedInDisaggregation(action,affected);
        setZeroOneInDisaggregation(action,zeroOne!=0);
        setWhenAtUBInDisaggregation(action,whenAtUB!=0);
        setAffectedToUBInDisaggregation(action,affectedToUB!=0);
        if (affected!=affectedLast||zeroOne!=zeroOneLast) {
          // new variable
          thisOne.index[put++]=action;
        } else if (whenAtUB!=whenAtUBLast||affectedToUB!=affectedToUBLast) {
          // new action - what can we discover
          thisOne.index[put++]=action;
          int j=cutVector_[i].sequence;
          int k=affected;
          if (zeroOne) {
            k=cutVector_[k].sequence;
            if (logLevel_>1)
              printf("For %d %d 0-1 pair",j,k) ;
          } else {
            if (logLevel_>1)
              printf("For %d %d pair",j,k) ;
          }
          if (logLevel_>1)
            printf(" old whenAtUB, affectedToUB %d %d, new whenAtUB, affectedToUB %d %d\n",
                   whenAtUBLast, affectedToUBLast,whenAtUB, affectedToUB);
        }
        affectedLast=affected;
        zeroOneLast=zeroOne;
        whenAtUBLast=whenAtUB;
        affectedToUBLast=affectedToUB;
      }
      if (put<number) {
        //printf("%d reduced from %d to %d\n",i,number,put);
        thisOne.length=put;
      }
    }
    // And look at all where two 0-1 variables involved
    for (i=0;i<number01Integers_;i++) {
      disaggregation & thisOne=cutVector_[i];
      int k;
      int number = thisOne.length;
      for (k=0;k<number;k++) {
        int affected = affectedInDisaggregation(thisOne.index[k]);
        bool zeroOne = zeroOneInDisaggregation(thisOne.index[k]);
        if (zeroOne&&static_cast<int>(affected)>i) {
          bool whenAtUB = whenAtUBInDisaggregation(thisOne.index[k]);
          bool affectedToUB = affectedToUBInDisaggregation(thisOne.index[k]);
          disaggregation otherOne=cutVector_[affected];
          int numberOther = otherOne.length;
          // Could do binary search if a lot
          int lastAction=-1;
          for (int j=0;j<numberOther;j++) {
            if (affectedInDisaggregation(otherOne.index[j])==i) {
              bool whenAtUBOther = whenAtUBInDisaggregation(otherOne.index[j]);
              bool affectedToUBOther = affectedToUBInDisaggregation(otherOne.index[j]);
              /* action -
                 0 -> x + y <=1 (1,1 impossible)
                 1 -> x - y <=0 (1,0 impossible)
                 2 -> -x + y <=0 (0,1 impossible)
                 3 -> -x -y <= -1 (0,0 impossible)
                10 -> x == y
                11 -> x + y == 1
                20 -> x == 0
                21 -> x == 1
                22 -> y == 0
                23 -> y == 1
              */
              int action=-1;
              if (whenAtUB) {
                if (affectedToUB) {
                  // x -> 1 => y -> 1
                  if (whenAtUBOther) {
                    if (affectedToUBOther) {
                      // y -> 1 => x -> 1
                      action=10; // x,y must be same
                    } else {
                      // y -> 1 => x -> 0 
                      action=20; // If x is 1 then contradiction
                    }
                  } else {
                    if (affectedToUBOther) {
                      // y -> 0 => x -> 1 
                      action=23; // if y is 0 then contradiction
                    } else {
                      // y -> 0 => x -> 0
                      action=1; // x,y 1,0 impossible 
                    }
                  }
                } else {
                  // x -> 1 => y -> 0
                  if (whenAtUBOther) {
                    if (affectedToUBOther) {
                      // y -> 1 => x -> 1
                      action=22; // If y is 1 then contradiction
                    } else {
                      // y -> 1 => x -> 0 
                      action=0; 
                    }
                  } else {
                    if (affectedToUBOther) {
                      // y -> 0 => x -> 1 
                      action=11; // x,y with same values impossible
                    } else {
                      // y -> 0 => x -> 0
                      action=20; // If x is 1 then contradiction
                    }
                  }
                }
              } else {
                if (affectedToUB) {
                  // x -> 0 => y -> 1
                  if (whenAtUBOther) {
                    if (affectedToUBOther) {
                      // y -> 1 => x -> 1
                      action=21; // If x is 0 then contradiction
                    } else {
                      // y -> 1 => x -> 0 
                      action=11; // x,y must be different
                    }
                  } else {
                    if (affectedToUBOther) {
                      // y -> 0 => x -> 1 
                      action=3; // one of x,y must be 1
                    } else {
                      // y -> 0 => x -> 0
                      action=23; // if y is 0 then contradiction
                    }
                  }
                } else {
                  // x -> 0 => y -> 0
                  if (whenAtUBOther) {
                    if (affectedToUBOther) {
                      // y -> 1 => x -> 1
                      action=2; // x,y 0,1 impossible
                    } else {
                      // y -> 1 => x -> 0 
                      action=22; // If y is 1 then contradiction
                    }
                  } else {
                    if (affectedToUBOther) {
                      // y -> 0 => x -> 1 
                      action=21; // if x is 0 then contradiction
                    } else {
                      // y -> 0 => x -> 0
                      action=10; // x,y must be same
                    }
                  }
                }
              }
              assert (action>=0)(static_cast<void> (0));
              if (action<4) {
                // clique - see if there
                if (oneFixStart_) {
                  switch (action) {
                  case 0:
                    break;
                  case 1:
                    break;
                  case 2:
                    break;
                  case 3:
                    break;
                  }
                  // If not can we add or strengthen
                }
                // check last action
                if (lastAction>=0) {
                  if (logLevel_>1)
                    printf("XX lastAction %d, this %d\n",lastAction,action);
                }
              } else if (action<12) {
                if (logLevel_>1)
                  printf("XX Could eliminate one of %d %d 0-1 variables %c\n",i,affected,
                         (lastAction>=0) ? '*' : ' ');
                if (info->strengthenRow) {
                  OsiRowCut rc;
                  int index[2];
                  double element[2];
                  index[0]=cutVector_[i].sequence;
                  element[0]=1.0;
                  index[1]=cutVector_[affected].sequence;
                  if (action==10) {
                    // 10 -> x == y
                    rc.setLb(0.0);
                    rc.setUb(0.0);   
                    element[1]= -1.0;
                  } else {
                    // 11 -> x + y == 1
                    rc.setLb(1.0);
                    rc.setUb(1.0);   
                    element[1]= 1.0;
                  }
                  rc.setRow(2,index,element,false);
                  cs.insert(rc);
                }
              } else {
                if (action<22) {
                  if (logLevel_>1)
                    printf("XX Could fix a 0-1 variable %d\n",i);
                } else {
                  if (logLevel_>1)
                    printf("XX Could fix a 0-1 variable %d\n",affected);
  }
              }
              //printf("%d when %d forces %d to %d , %d when %d forces %d to %d\n",
              //     i,whenAtUB,affected,affectedToUB, 
              //     affected, whenAtUBOther,i, affectedToUBOther);
            }
          }
        }
      }
    }
    delete [] sortit;
  }
  if (cutVector_) {
    // now see if any disaggregation cuts are violated
    for (i=0;i<number01Integers_;i++) {
int j=cutVector_[i].sequence;
double solInt=colsol[j];
double  upper, solValue;
int icol;
int index[2];
double element[2];
if (colUpper[j]-colLower[j]>1.0e-8) {
 double away = fabs(0.5-(solInt-floor(solInt)));
 if (away<0.4999999) {
   disaggregation thisOne=cutVector_[i];
   int k;
   OsiRowCut rc;
   for (k=0;k<thisOne.length;k++) {
     icol = affectedInDisaggregation(thisOne.index[k]);
            if (zeroOneInDisaggregation(thisOne.index[k]))
              icol = cutVector_[icol].sequence;
     solValue=colsol[icol];
     upper=colUpper_[icol];
            double infeasibility=0.0;
            if (!whenAtUBInDisaggregation(thisOne.index[k])) {
              if (!affectedToUBInDisaggregation(thisOne.index[k])) {
                // delta -> 0 => x to lb (at present just 0)
                infeasibility = solValue - upper * solInt;
                if (infeasibility > 1.0e-3) {
                  rc.setLb(-COIN_DBL_MAX);
                  rc.setUb(0.0);
                  index[0]=icol;
                  element[0]=1.0;
                  index[1]=j;
                  element[1]= -upper;
                } else {
                  infeasibility=0.0;
                }
              } else {
                // delta -> 0 => x to ub
                abort();
              }
            } else {
              if (affectedToUBInDisaggregation(thisOne.index[k])) {
                // delta -> 1 => x to ub (?)
                icol = affectedInDisaggregation(thisOne.index[k]);
                if (zeroOneInDisaggregation(thisOne.index[k]))
                  icol = cutVector_[icol].sequence;
                solValue=colsol[icol];
                upper=colUpper_[icol];
                if (!colLower[icol]) {
                  infeasibility = upper * solInt - solValue;
                  if (infeasibility > 1.0e-3) {
                    rc.setLb(-COIN_DBL_MAX);
                    rc.setUb(0.0);
                    index[0]=icol;
                    element[0]=-1.0;
                    index[1]=j;
                    element[1]= upper;
                  } else {
                    infeasibility=0.0;
                  }
                } else {
                  assert (upper==colLower[icol])(static_cast<void> (0));
                  infeasibility=0.0;
                }
              } else {
                // delta + delta2 <= 1
                assert (zeroOneInDisaggregation(thisOne.index[k]))(static_cast<void> (0));
                // delta -> 1 => delta2 -> 0
                icol = affectedInDisaggregation(thisOne.index[k]);
                icol = cutVector_[icol].sequence;
                // only do if icol > j
                if (icol >j && colUpper[icol] ) {
                  solValue=colsol[icol];
                  if (!colLower[icol]) {
                    infeasibility = solInt + solValue - 1.0;
                    if (infeasibility > 1.0e-3) {
                      rc.setLb(-COIN_DBL_MAX);
                      rc.setUb(1.0);
                      index[0]=icol;
                      element[0]=1.0;
                      index[1]=j;
                      element[1]= 1.0;
                    } else {
                      infeasibility=0.0;
                    }
                  } else {
                    assert (upper==colLower[icol])(static_cast<void> (0));
                    infeasibility=0.0;
                  }
                }
              }
            }
            if (infeasibility) {
              rc.setEffectiveness(infeasibility);
              rc.setRow(2,index,element,false);
              if (logLevel_>1)
                printf("%g <= %g * x%d + %g * x%d <= %g\n",
                       rc.lb(),element[0],index[0],element[1],index[1],rc.ub());
2873#ifdef CGL_DEBUG
              if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
2875#endif
              rowCut.addCutIfNotDuplicate(rc);
            }
   }
 }
}
    }
  }
}
delete [] markR;
delete [] minR;
delete [] maxR;
// Add in row cuts
if (!ninfeas) {
  rowCut.addCuts(cs,info->strengthenRow,0);
}
// delete stuff
delete rowCopy;
delete columnCopy;
if (rowCopy_) {
  delete [] rowLower;
  delete [] rowUpper;
}
delete [] intVar;
delete [] rowStartPos;
delete [] realRows;
// and put back unreasonable bounds on integer variables
const double * trueLower = si.getColLower();
const double * trueUpper = si.getColUpper();
if (!ninfeas) {
  for (i=0;i<nCols;i++) {
    if (intVarOriginal[i]==2) {
if (colUpper[i] == CGL_REASONABLE_INTEGER_BOUND1.23456789e10) 
 colUpper[i] = trueUpper[i];
if (colLower[i] == -CGL_REASONABLE_INTEGER_BOUND1.23456789e10) 
 colLower[i] = trueLower[i];
    }
  }
} else {
  memcpy(colLower,trueLower,nCols*sizeof(double));
  memcpy(colUpper,trueUpper,nCols*sizeof(double));
}
if (!info->inTree&&((info->options&4)==4||((info->options&8)&&!info->pass))) {
  int numberRowCutsAfter = cs.sizeRowCuts();
  for (int i=numberRowCutsBefore;i<numberRowCutsAfter;i++)
    cs.rowCutPtr(i)->setGloballyValid();
}
return ninfeas;
2923}
2924// Does probing and adding cuts
2925int CglProbing::probe( const OsiSolverInterface & si, 
       const OsiRowCutDebugger *
2927#ifdef CGL_DEBUG
       debugger
2929#endif 
       ,OsiCuts & cs, 
       double * colLower, double * colUpper, 
       CoinPackedMatrix *rowCopy,
       CoinPackedMatrix *columnCopy,
       const CoinBigIndex * rowStartPos,const int * realRows, 
       const double * rowLower, const double * rowUpper,
       const char * intVar, double * minR, double * maxR, 
       int * markR, 
       CglTreeInfo * info)
2939{
int nRows=rowCopy->getNumRows();
int nRowsSafe=CoinMin(nRows,si.getNumRows());
int nCols=rowCopy->getNumCols();
const double * currentColLower = si.getColLower();
const double * currentColUpper = si.getColUpper();
// Set up maxes
int maxStack = info->inTree ? maxStack_ : maxStackRoot_;
int maxPass = info->inTree ? maxPass_ : maxPassRoot_;
if ((totalTimesCalled_%10)==-1) {
  int newMax=CoinMin(2*maxStack,50);
  maxStack=CoinMax(newMax,maxStack);
}
2952#define ONE_ARRAY
2953#ifdef ONE_ARRAY
unsigned int DIratio = sizeof(double)/sizeof(int);
assert (DIratio==1||DIratio==2)(static_cast<void> (0));
int nSpace = 8*nCols+4*nRows+2*maxStack;
nSpace += (4*nCols+nRows+maxStack+DIratio-1)>>(DIratio-1);
double * colsol = new double[nSpace];
double * djs = colsol + nCols;
double * columnGap = djs + nCols;
double * saveL = columnGap + nCols;
double * saveU = saveL + 2*nCols;
double * saveMin = saveU + 2*nCols;
double * saveMax = saveMin + nRows;
double * largestPositiveInRow = saveMax + nRows;
double * largestNegativeInRow = largestPositiveInRow + nRows;
double * element = largestNegativeInRow + nRows;
double * lo0 = element + nCols;
double * up0 = lo0 + maxStack;
int * markC = reinterpret_cast<int *> (up0+maxStack);
int * stackC = markC + nCols;
int * stackR = stackC + 2*nCols;
int * index = stackR + nRows;
int * stackC0 = index + nCols;
2975#else 
double * colsol = new double[nCols];
double * djs = new double[nCols];
double * columnGap = new double [nCols];
double * saveL = new double [2*nCols];
double * saveU = new double [2*nCols];
double * saveMin = new double [nRows];
double * saveMax = new double [nRows];
double * largestPositiveInRow = new double [nRows];
double * largestNegativeInRow = new double [nRows];
double * element = new double[nCols];
double * lo0 = new double[maxStack];
double * up0 = new double[maxStack];
int * markC = new int [nCols];
int * stackC = new int [2*nCols];
int * stackR = new int [nRows];
int * index = new int[nCols];
int * stackC0 = new int[maxStack];
2993#endif
// Let us never add more than twice the number of rows worth of row cuts
// Keep cuts out of cs until end so we can find duplicates quickly
2996#define PROBING4
2997#ifdef PROBING4
int nRowsFake = info->inTree ? nRowsSafe/3 : nRowsSafe*10;
2999#else
int nRowsFake = info->inTree ? nRowsSafe/3 : nRowsSafe;
3001#endif
if (!info->inTree&&!info->pass) 
  nRowsFake *= 10;
bool justReplace = ((info->options&64)!=0)&&(realRows!=NULL__null);
if (justReplace) {
  nRowsFake=nRows;
}
row_cut rowCut(nRowsFake, !info->inTree);
totalTimesCalled_++;
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const double * rowElements = rowCopy->getElements();
const int * row = columnCopy->getIndices();
const CoinBigIndex * columnStart = columnCopy->getVectorStarts();
const int * columnLength = columnCopy->getVectorLengths(); 
const double * columnElements = columnCopy->getElements();
3017#define MOVE_SINGLETONS
3018#ifdef MOVE_SINGLETONS
const double * objective = si.getObjCoefficients();
const int * columnLength2 = si.getMatrixByCol()->getVectorLengths(); 
3021#endif
bool anyColumnCuts=false;
int ninfeas=0;
int rowCuts;
double disaggEffectiveness;
/* clean up djs and solution */
CoinMemcpyN(si.getReducedCost(),nCols,djs);
CoinMemcpyN( si.getColSolution(),nCols,colsol);
disaggEffectiveness=1.0e-3;
rowCuts=rowCuts_;
//CoinBigIndex * rowStartPos = new CoinBigIndex [nRows];
3032#ifndef NDEBUG1
const int * rowLength = rowCopy->getVectorLengths(); 
3034#endif
for (int i=0;i<nRows;i++) {
  assert (rowStart[i]+rowLength[i]==rowStart[i+1])(static_cast<void> (0));
  int kk;
3038#ifndef NDEBUG1
  for ( kk =rowStart[i];kk<rowStart[i+1];kk++) {
    double value = rowElements[kk];
    if (value>0.0) 
break;
  }
  assert (rowStartPos[i]==kk)(static_cast<void> (0));
3045#endif
  double value;
  value=0.0;
  for ( kk =rowStart[i];kk<rowStartPos[i];kk++) {
    int iColumn = column[kk];
    double gap = CoinMin(1.0e100,colUpper[iColumn]-colLower[iColumn]);
    value = CoinMin(value,gap*rowElements[kk]);
  }
  largestNegativeInRow[i]=value;
  value=0.0;
  for ( ;kk<rowStart[i+1];kk++) {
    int iColumn = column[kk];
    double gap = CoinMin(1.0e100,colUpper[iColumn]-colLower[iColumn]);
    value = CoinMax(value,gap*rowElements[kk]);
  }
  largestPositiveInRow[i]=value;
}
double direction = si.getObjSense();
for (int i = 0; i < nCols; ++i) {
  double djValue = djs[i]*direction;
  double gap=colUpper[i]-colLower[i];
  if (gap>1.0e-8) {
    if (colsol[i]<colLower[i]+primalTolerance_) {
      colsol[i]=colLower[i];
      djs[i] = CoinMax(0.0,djValue);
    } else if (colsol[i]>colUpper[i]-primalTolerance_) {
      colsol[i]=colUpper[i];
      djs[i] = CoinMin(0.0,djValue);
    } else {
      djs[i]=0.0;
    }
  }
  columnGap[i]=gap-primalTolerance_;
}

int ipass=0,nfixed=-1;

double cutoff;
bool cutoff_available = si.getDblParam(OsiDualObjectiveLimit,cutoff);
if (!cutoff_available||usingObjective_<0) { // cut off isn't set or isn't valid
  cutoff = si.getInfinity();
}
cutoff *= direction;
if (fabs(cutoff)>1.0e30)
  assert (cutoff>1.0e30)(static_cast<void> (0));
double current = si.getObjValue();
current *= direction;
/* for both way coding */
int nstackC0=-1;
int nstackR,nstackC;
//int nFix=0;
for (int i=0;i<nCols;i++) {
  if (colUpper[i]-colLower[i]<1.0e-8) {
    markC[i]=3;
    //nFix++;
  } else {
    markC[i]=0;
    if (colUpper[i]>1.0e10)
markC[i] |= 8;
    if (colLower[i]<-1.0e10)
markC[i] |= 4;
  }
}
//printf("PROBE %d fixed out of %d\n",nFix,nCols);
double tolerance = 1.0e1*primalTolerance_;
// If we are going to replace coefficient then we don't need to be effective
//double needEffectiveness = info->strengthenRow ? -1.0e10 : 1.0e-3;
double needEffectiveness = info->strengthenRow ? 1.0e-8 : 1.0e-3;
if (justReplace&&(info->pass&1)!=0)
  needEffectiveness=-1.0e10;
if (PROBING_EXTRA_STUFFfalse) {
  int nCut=0;
  for (int iRow=0;iRow<nRows;iRow++) {
    int numberInt=0;
    int whichInt=-1;
    int numberNeg=0;
    double sumFixed=0.0;
    double intValue=0.0;
    for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow+1];j++) {
      int jColumn = column[j];
      double value = rowElements[j];
      if (colUpper[jColumn] > colLower[jColumn]+1.0e-8) {
        if (intVar[jColumn]) {
          numberInt++;
          whichInt=jColumn;
          intValue=value;
        } else if (value<0) {
          numberNeg++;
        }
      } else {
        sumFixed += colLower[jColumn]*value;
      }
    }
    if (numberInt==1&&numberNeg==0&&intValue<0.0&&!rowUpper[iRow]&&rowLower[iRow]<-1.0e30&&!sumFixed) {
      double intSol = colsol[whichInt];
      for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow+1];j++) {
        int jColumn = column[j];
        //double value = rowElements[j];
        if (colUpper[jColumn] > colLower[jColumn]+1.0e-8) {
          if (!intVar[jColumn]) {
            if (colLower[jColumn]||colUpper[jColumn]>1.0)
              continue;;
            double upper = colUpper[jColumn];
            if (colsol[jColumn]>intSol*upper+1.0e-4) {
              nCut++;
              OsiRowCut rc;
              rc.setLb(-COIN_DBL_MAX);
              rc.setUb(0.0);
              rc.setEffectiveness(1.0e-5);
              int index[2];
              double element[2];
              index[0]=jColumn;
              index[1]=whichInt;
              element[0]=1.0;
              element[1]=-upper;
              rc.setRow(2,index,element,false);
              cs.insert(rc);
            }
          }
        }
      }
    }
  }
  if (nCut)
    printf("%d possible cuts\n",nCut);
}
bool saveFixingInfo =  false;
3172#if PROBING1000
CglTreeProbingInfo * probingInfo = dynamic_cast<CglTreeProbingInfo *> (info);
const int * backward = NULL__null;
const int * integerVariable = NULL__null;
const int * toZero = NULL__null;
const int * toOne = NULL__null;
const fixEntry * fixEntries=NULL__null;
3179#endif
if (info->inTree) {
3181#if PROBING1000
  backward = probingInfo->backward();
  integerVariable = probingInfo->integerVariable();
  toZero = probingInfo->toZero();
  toOne = probingInfo->toOne();
  fixEntries=probingInfo->fixEntries();
3187#endif
} else {
  saveFixingInfo = (info->initializeFixing(&si)>0);
}
while (ipass<maxPass&&nfixed) {
  int iLook;
  ipass++;
  //printf("pass %d\n",ipass);
  nfixed=0;
  int justFix= (!info->inTree&&!info->pass) ? -1 : 0;
  int maxProbe = info->inTree ? maxProbe_ : maxProbeRoot_;
  if (justFix<0)
    maxProbe=numberThisTime_;
  if (maxProbe==123) {
    // Try and be a bit intelligent
    maxProbe=0;
    if (!info->inTree) {
if (!info->pass||numberThisTime_<-100) {
 maxProbe=numberThisTime_;
} else {
 int cutDown = 4;
 int offset = info->pass % cutDown;
 int i;
 int k=0;
 int kk=offset;
 for (i=0;i<numberThisTime_;i++) {
   if (!kk) {
3214#define XXXXXX
3215#ifdef XXXXXX
     lookedAt_[maxProbe]=lookedAt_[i];
3217#endif
     maxProbe++;
     kk=cutDown-1;
   } else {
     stackC[k++]=lookedAt_[i];
     kk--;
   }
 }
3225#ifdef XXXXXX
 memcpy(lookedAt_+maxProbe,stackC,k*sizeof(int));
3227#endif
}
    } else {
// in tree
if (numberThisTime_<200) {
 maxProbe=numberThisTime_;
} else {
 int cutDown = CoinMax(numberThisTime_/100,4);
 int offset = info->pass % cutDown;
 int i;
 int k=0;
 int kk=offset;
 for (i=0;i<numberThisTime_;i++) {
   if (!kk) {
3241#ifdef XXXXXX
     lookedAt_[maxProbe]=lookedAt_[i];
3243#endif
     maxProbe++;
     kk=cutDown-1;
   } else {
     stackC[k++]=lookedAt_[i];
     kk--;
   }
 }
3251#ifdef XXXXXX
 memcpy(lookedAt_+maxProbe,stackC,k*sizeof(int));
3253#endif
}
    }
  }
  int leftTotalStack=maxStack*CoinMax(200,maxProbe);
3258#ifdef PROBING5
  if (!info->inTree&&!info->pass)
    leftTotalStack = 1234567890;
3261#endif
  //printf("maxStack %d maxPass %d numberThisTime %d info pass %d\n",
  //   maxStack,maxPass,numberThisTime_,info->pass);
  for (iLook=0;iLook<numberThisTime_;iLook++) {
    double solval;
    double down;
    double up;
    if (rowCut.outOfSpace()||leftTotalStack<=0) {
if (!justFix&&(!nfixed||info->inTree)) {
3270#ifdef COIN_DEVELOP
 if (!info->inTree)
   printf("Exiting a on pass %d, maxProbe %d\n",
   ipass,maxProbe);
3274#endif	  
 break;
} else if (justFix<=0) {
 if (!info->inTree) {
   rowCuts=0;
   justFix=1;
   disaggEffectiveness=COIN_DBL_MAX;
   needEffectiveness=COIN_DBL_MAX;
   //maxStack=10;
   maxPass=1;
 } else if (!nfixed) {
3285#ifdef COIN_DEVELOP
   printf("Exiting b on pass %d, maxProbe %d\n",
   ipass,maxProbe);
3288#endif	  
   break;
 }
}
    }
    int j=lookedAt_[iLook];
    //if (j==231||j==226)
    //printf("size %d %d j is %d\n",rowCut.numberCuts(),cs.sizeRowCuts(),j);//printf("looking at %d (%d out of %d)\n",j,iLook,numberThisTime_); 
    solval=colsol[j];
    down = floor(solval+tolerance);
    up = ceil(solval-tolerance);
    if(columnGap[j]<0.0) markC[j]=3;
    if ((markC[j]&3)!=0||!intVar[j]) continue;
    double saveSolval = solval;
    if (solval>=colUpper[j]-tolerance||solval<=colLower[j]+tolerance||up==down) {
if (solval<=colLower[j]+2.0*tolerance) {
 solval = colLower[j]+1.0e-1;
 down=colLower[j];
 up=down+1.0;
} else if (solval>=colUpper[j]-2.0*tolerance) {
 solval = colUpper[j]-1.0e-1;
 up=colUpper[j];
 down=up-1;
} else {
        // odd
        up=down+1.0;
        solval = down+1.0e-1;
      }
    }
    assert (up<=colUpper[j])(static_cast<void> (0));
    assert (down>=colLower[j])(static_cast<void> (0));
    assert (up>down)(static_cast<void> (0));
    int istackC,iway, istackR;
    int way[]={1,2,1};
    int feas[]={1,2,4};
    int feasible=0;
    int notFeasible;
    for (iway=0;iway<3;iway ++) {
      int fixThis=0;
      double objVal=current;
      int goingToTrueBound=0;
      stackC[0]=j;
      markC[j]=way[iway];
      double solMovement;
      double movement;
      if (way[iway]==1) {
        movement=down-colUpper[j];
        solMovement = down-colsol[j];
        assert(movement<-0.99999)(static_cast<void> (0));
        if (fabs(down-colLower[j])<1.0e-7) {
          goingToTrueBound=2;
          down=colLower[j];
        }
      } else {
        movement=up-colLower[j];
        solMovement = up-colsol[j];
        assert(movement>0.99999)(static_cast<void> (0));
        if (fabs(up-colUpper[j])<1.0e-7) {
          goingToTrueBound=2;
          up=colUpper[j];
        }
      }
      if (goingToTrueBound&&(colUpper[j]-colLower[j]>1.5||colLower[j]))
        goingToTrueBound=1;
      // switch off disaggregation if not wanted
      if ((rowCuts&1)==0)
        goingToTrueBound=0;
bool canReplace = info->strengthenRow&&(goingToTrueBound==2);
3356#ifdef PRINT_DEBUG
      if (fabs(movement)>1.01) {
        printf("big %d %g %g %g\n",j,colLower[j],solval,colUpper[j]);
      }
3360#endif
      if (solMovement*djs[j]>0.0)
        objVal += solMovement*djs[j];
      nstackC=1;
      nstackR=0;
      saveL[0]=colLower[j];
      saveU[0]=colUpper[j];
      assert (saveU[0]>saveL[0])(static_cast<void> (0));
      notFeasible=0;
      if (movement<0.0) {
        colUpper[j] += movement;
        colUpper[j] = floor(colUpper[j]+0.5);
 columnGap[j] = colUpper[j]-colLower[j]-primalTolerance_;
3373#ifdef PRINT_DEBUG
        printf("** Trying %d down to 0\n",j);
3375#endif
      } else {
        colLower[j] += movement;
        colLower[j] = floor(colLower[j]+0.5);
 columnGap[j] = colUpper[j]-colLower[j]-primalTolerance_;
3380#ifdef PRINT_DEBUG
        printf("** Trying %d up to 1\n",j);
3382#endif
      }
      if (fabs(colUpper[j]-colLower[j])<1.0e-6)
        markC[j]=3; // say fixed
markC[j] &= ~12;
if (colUpper[j]>1.0e10)
 markC[j] |= 8;
if (colLower[j]<-1.0e10)
 markC[j] |= 4;
      istackC=0;
      /* update immediately */
int k;
      for ( k=columnStart[j];k<columnStart[j]+columnLength[j];k++) {
        int irow = row[k];
        double value = columnElements[k];
        assert (markR[irow]!=-2)(static_cast<void> (0));
        if (markR[irow]==-1) {
          stackR[nstackR]=irow;
          markR[irow]=nstackR;
          saveMin[nstackR]=minR[irow];
          saveMax[nstackR]=maxR[irow];
          nstackR++;
3404#if 0
        } else if (markR[irow]==-2) {
          continue;
3407#endif
        }
        /* could check immediately if violation */
        if (movement>0.0) {
          /* up */
          if (value>0.0) {
            /* up does not change - down does */
            if (minR[irow]>-1.0e10)
              minR[irow] += value;
            if (minR[irow]>rowUpper[irow]+1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          } else {
            /* down does not change - up does */
            if (maxR[irow]<1.0e10)
              maxR[irow] += value;
            if (maxR[irow]<rowLower[irow]-1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          }
        } else {
          /* down */
          if (value<0.0) {
            /* up does not change - down does */
            if (minR[irow]>-1.0e10)
              minR[irow] -= value;
            if (minR[irow]>rowUpper[irow]+1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          } else {
            /* down does not change - up does */
            if (maxR[irow]<1.0e10)
              maxR[irow] -= value;
            if (maxR[irow]<rowLower[irow]-1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          }
        }
      }
      while (istackC<nstackC&&nstackC<maxStack) { // could be istackC<maxStack?
 leftTotalStack--;
        int jway;
        int jcol =stackC[istackC];
        jway=markC[jcol];
        // If not first and fixed then skip
        if ((jway&3)==3&&istackC) {
          //istackC++;
          //continue;
          //printf("fixed %d on stack\n",jcol);
        }
3465#if PROBING1000
 if (backward) {
   int jColumn = backward[jcol];
   if (jColumn>=0) {
     int nFix=0;
     // 0-1 see what else could be fixed
     if (jway==1) {
// fixed to 0
int j;
for ( j=toZero_[jColumn];j<toOne_[jColumn];j++) {
  int kColumn=fixEntry_[j].sequence;
  kColumn = integerVariable_[kColumn];
  bool fixToOne = fixEntry_[j].oneFixed;
  if (fixToOne) {
    if (colLower[kColumn]==0.0) {
      if (colUpper[kColumn]==1.0) {
	// See if on list
	if (!(markC[kColumn]&3)) {
	  if(nStackC<nCols) {
	    stackC[nstackC]=kColumn;
	    saveL[nstackC]=colLower[kColumn];
	    saveU[nstackC]=colUpper[kColumn];
	    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	    assert (nstackC<nCols)(static_cast<void> (0));
	    nstackC++;
	    markC[kColumn]|=2;
	    nFix++;
	  }
	} else if ((markC[kColumn]&3)==1) {
	  notFeasible=true;
	}
      } else {
	// infeasible!
	notFeasible=true;
      }
    }
  } else {
    if (colUpper[kColumn]==1.0) {
      if (colLower[kColumn]==0.0) {
	// See if on list
	if (!(markC[kColumn]&3)) {
	  if(nStackC<nCols) {
	    stackC[nstackC]=kColumn;
	    saveL[nstackC]=colLower[kColumn];
	    saveU[nstackC]=colUpper[kColumn];
	    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	    assert (nstackC<nCols)(static_cast<void> (0));
	    nstackC++;
	    markC[kColumn]|=1;
	    nFix++;
	  }
	} else if ((markC[kColumn]&3)==2) {
	  notFeasible=true;
	}
      } else {
	// infeasible!
	notFeasible=true;
      }
    }
  }
}
     } else if (jway==2) {
int j;
for ( j=toOne_[jColumn];j<toZero_[jColumn+1];j++) {
  int kColumn=fixEntry_[j].sequence;
  kColumn = integerVariable_[kColumn];
  bool fixToOne = fixEntry_[j].oneFixed;
  if (fixToOne) {
    if (colLower[kColumn]==0.0) {
      if (colUpper[kColumn]==1.0) {
	// See if on list
	if (!(markC[kColumn]&3)) {
	  if(nStackC<nCols) {
	    stackC[nstackC]=kColumn;
	    saveL[nstackC]=colLower[kColumn];
	    saveU[nstackC]=colUpper[kColumn];
	    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	    assert (nstackC<nCols)(static_cast<void> (0));
	    nstackC++;
	    markC[kColumn]|=2;
	    nFix++;
	  }
	} else if ((markC[kColumn]&3)==1) {
	  notFeasible=true;
	}
      } else {
	// infeasible!
	notFeasible=true;
      }
    }
  } else {
    if (colUpper[kColumn]==1.0) {
      if (colLower[kColumn]==0.0) {
	// See if on list
	if (!(markC[kColumn]&3)) {
	  if(nStackC<nCols) {
	    stackC[nstackC]=kColumn;
	    saveL[nstackC]=colLower[kColumn];
	    saveU[nstackC]=colUpper[kColumn];
	    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	    assert (nstackC<nCols)(static_cast<void> (0));
	    nstackC++;
	    markC[kColumn]|=1;
	    nFix++;
	  }
	} else if ((markC[kColumn]&3)==2) {
	  notFeasible=true;
	}
      } else {
	// infeasible!
	notFeasible=true;
      }
    }
  }
}
     }
   }
 }
3583#endif
        for (k=columnStart[jcol];k<columnStart[jcol]+columnLength[jcol];k++) {
          // break if found not feasible
          if (notFeasible)
            break;
          int irow = row[k];
   /* see if anything forced */
   int rStart = rowStart[irow];
   int rEnd = rowStartPos[irow];
   double rowUp = rowUpper[irow];
   double rowUp2=0.0;
   bool doRowUpN;
   bool doRowUpP;
   if (rowUp<1.0e10) {
     doRowUpN=true;
     doRowUpP=true;
     rowUp2 = rowUp-minR[irow];
     if (rowUp2<-primalTolerance_) {
notFeasible=true;
break;
     } else {
if (rowUp2+largestNegativeInRow[irow]>0)
  doRowUpN=false;
if (rowUp2-largestPositiveInRow[irow]>0)
  doRowUpP=false;
     }
   } else {
     doRowUpN=false;
     doRowUpP=false;
     rowUp2=COIN_DBL_MAX;
   }
   double rowLo = rowLower[irow];
   double rowLo2=0.0;
   bool doRowLoN;
   bool doRowLoP;
   if (rowLo>-1.0e10) {
     doRowLoN=true;
     doRowLoP=true;
     rowLo2 = rowLo-maxR[irow];
     if (rowLo2>primalTolerance_) {
notFeasible=true;
break;
     } else {
if (rowLo2-largestNegativeInRow[irow]<0)
  doRowLoN=false;
if (rowLo2+largestPositiveInRow[irow]<0)
  doRowLoP=false;
     }
   } else {
     doRowLoN=false;
     doRowLoP=false;
     rowLo2=-COIN_DBL_MAX;
   }
   if (doRowUpN&&doRowLoN) {
     //doRowUpN=doRowLoN=false;
     // Start neg values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol=column[kk];
int markIt=markC[kcol];
if ((markIt&3)!=3) {
  double value2=rowElements[kk];
  if (colUpper[kcol]<=1e10)
    assert ((markIt&8)==0)(static_cast<void> (0));
  else
    assert ((markIt&8)!=0)(static_cast<void> (0));
  if (colLower[kcol]>=-1e10)
    assert ((markIt&4)==0)(static_cast<void> (0));
  else
    assert ((markIt&4)!=0)(static_cast<void> (0));
  assert (value2<0.0)(static_cast<void> (0));
  double gap = columnGap[kcol]*value2;
  bool doUp = (rowUp2 + gap < 0.0);
  bool doDown = (rowLo2 -gap > 0.0);
  if (doUp||doDown) {
    double moveUp=0.0;
    double moveDown=0.0;
    double newUpper=-1.0;
    double newLower=1.0;
    if ( doUp&&(markIt&(2+8))==0) {
      double dbound = colUpper[kcol]+rowUp2/value2;
      if (intVar[kcol]) {
	markIt |= 2;
	newLower = ceil(dbound-primalTolerance_);
      } else {
	newLower=dbound;
	if (newLower+primalTolerance_>colUpper[kcol]&&
	    newLower-primalTolerance_<=colUpper[kcol]) {
	  newLower=colUpper[kcol];
	  markIt |= 2;
	  //markIt=3;
	} else {
	  // avoid problems - fix later ?
	  markIt=3;
	}
      }
      moveUp = newLower-colLower[kcol];
    }
    if ( doDown&&(markIt&(1+4))==0) {
      double dbound = colLower[kcol] + rowLo2/value2;
      if (intVar[kcol]) {
	markIt |= 1;
	newUpper = floor(dbound+primalTolerance_);
      } else {
	newUpper=dbound;
	if (newUpper-primalTolerance_<colLower[kcol]&&
	    newUpper+primalTolerance_>=colLower[kcol]) {
	  newUpper=colLower[kcol];
	  markIt |= 1;
	  //markIt=3;
	} else {
	  // avoid problems - fix later ?
	  markIt=3;
	}
      }
      moveDown = newUpper-colUpper[kcol];
    }
    if (!moveUp&&!moveDown)
      continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (moveUp&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newLower>colsol[kcol]) {
	if (djs[kcol]<0.0) {
	  /* should be infeasible */
	  assert (newLower>colUpper[kcol]+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveUp*djs[kcol];
	}
      }
      if (intVar[kcol]) 
	newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
      colLower[kcol]=newLower;
      columnGap[kcol] = colUpper[kcol]-newLower-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* up */
	if (value>0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveUp;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveUp;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	}
      }
    }
    if (moveDown&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newUpper<colsol[kcol]) {
	if (djs[kcol]>0.0) {
	  /* should be infeasible */
	  assert (colLower[kcol]>newUpper+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveDown*djs[kcol];
	}
      }
      if (intVar[kcol])
	newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
      colUpper[kcol]=newUpper;
      columnGap[kcol] = newUpper-colLower[kcol]-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* down */
	if (value<0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveDown;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveDown;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rStart->rPos
   } else if (doRowUpN) {
     // Start neg values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol =column[kk];
int markIt=markC[kcol];
if ((markIt&3)!=3) {
  double value2=rowElements[kk];
  double gap = columnGap[kcol]*value2;
  if (!(rowUp2 + gap < 0.0))
    continue;
  double moveUp=0.0;
  double newLower=1.0;
  if ((markIt&(2+8))==0) {
    double dbound = colUpper[kcol]+rowUp2/value2;
    if (intVar[kcol]) {
      markIt |= 2;
      newLower = ceil(dbound-primalTolerance_);
    } else {
      newLower=dbound;
      if (newLower+primalTolerance_>colUpper[kcol]&&
	  newLower-primalTolerance_<=colUpper[kcol]) {
	newLower=colUpper[kcol];
	markIt |= 2;
	//markIt=3;
      } else {
	// avoid problems - fix later ?
	markIt=3;
      }
    }
    moveUp = newLower-colLower[kcol];
    if (!moveUp)
      continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (moveUp&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newLower>colsol[kcol]) {
	if (djs[kcol]<0.0) {
	  /* should be infeasible */
	  assert (newLower>colUpper[kcol]+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveUp*djs[kcol];
	}
      }
      if (intVar[kcol]) 
	newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
      colLower[kcol]=newLower;
      columnGap[kcol] = colUpper[kcol]-newLower-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* up */
	if (value>0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveUp;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveUp;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rStart->rPos
   } else if (doRowLoN) {
     // Start neg values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol =column[kk];
if ((markC[kcol]&3)!=3) {
  double moveDown=0.0;
  double newUpper=-1.0;
  double value2=rowElements[kk];
  int markIt=markC[kcol];
  assert (value2<0.0)(static_cast<void> (0));
  double gap = columnGap[kcol]*value2;
  bool doDown = (rowLo2 -gap > 0.0);
  if (doDown&& (markIt&(1+4))==0 ) {
    double dbound = colLower[kcol] + rowLo2/value2;
    if (intVar[kcol]) {
      markIt |= 1;
      newUpper = floor(dbound+primalTolerance_);
    } else {
      newUpper=dbound;
      if (newUpper-primalTolerance_<colLower[kcol]&&
	  newUpper+primalTolerance_>=colLower[kcol]) {
	newUpper=colLower[kcol];
	markIt |= 1;
	//markIt=3;
      } else {
	// avoid problems - fix later ?
	markIt=3;
      }
    }
    moveDown = newUpper-colUpper[kcol];
    if (!moveDown)
    continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (moveDown&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newUpper<colsol[kcol]) {
	if (djs[kcol]>0.0) {
	  /* should be infeasible */
	  assert (colLower[kcol]>newUpper+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveDown*djs[kcol];
	}
      }
      if (intVar[kcol])
	newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
      colUpper[kcol]=newUpper;
      columnGap[kcol] = newUpper-colLower[kcol]-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* down */
	if (value<0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveDown;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveDown;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rStart->rPos
   }
   rStart = rEnd;
   rEnd = rowStart[irow+1];
   if (doRowUpP&&doRowLoP) {
     //doRowUpP=doRowLoP=false;
     // Start pos values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol=column[kk];
int markIt=markC[kcol];
if ((markIt&3)!=3) {
  double value2=rowElements[kk];
  assert (value2 > 0.0)(static_cast<void> (0));
  /* positive element */
  double gap = columnGap[kcol]*value2;
  bool doDown = (rowLo2 + gap > 0.0);
  bool doUp = (rowUp2 - gap < 0.0);
  if (doDown||doUp) {
    double moveUp=0.0;
    double moveDown=0.0;
    double newUpper=-1.0;
    double newLower=1.0;
    if (doDown&&(markIt&(2+8))==0) {
      double dbound = colUpper[kcol] + rowLo2/value2;
      if (intVar[kcol]) {
	markIt |= 2;
	newLower = ceil(dbound-primalTolerance_);
      } else {
	newLower=dbound;
	if (newLower+primalTolerance_>colUpper[kcol]&&
	    newLower-primalTolerance_<=colUpper[kcol]) {
	  newLower=colUpper[kcol];
	  markIt |= 2;
	  //markIt=3;
	} else {
	  // avoid problems - fix later ?
	  markIt=3;
	}
      }
      moveUp = newLower-colLower[kcol];
    }
    if (doUp&&(markIt&(1+4))==0) {
      double dbound = colLower[kcol] + rowUp2/value2;
      if (intVar[kcol]) {
	markIt |= 1;
	newUpper = floor(dbound+primalTolerance_);
      } else {
	newUpper=dbound;
	if (newUpper-primalTolerance_<colLower[kcol]&&
	    newUpper+primalTolerance_>=colLower[kcol]) {
	  newUpper=colLower[kcol];
	  markIt |= 1;
	  //markIt=3;
	} else {
	  // avoid problems - fix later ?
	  markIt=3;
	}
      }
      moveDown = newUpper-colUpper[kcol];
    }
    if (!moveUp&&!moveDown)
      continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (moveUp&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newLower>colsol[kcol]) {
	if (djs[kcol]<0.0) {
	  /* should be infeasible */
	  assert (newLower>colUpper[kcol]+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveUp*djs[kcol];
	}
      }
      if (intVar[kcol]) 
	newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
      colLower[kcol]=newLower;
      columnGap[kcol] = colUpper[kcol]-newLower-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* up */
	if (value>0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveUp;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveUp;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (moveDown&&nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newUpper<colsol[kcol]) {
	if (djs[kcol]>0.0) {
	  /* should be infeasible */
	  assert (colLower[kcol]>newUpper+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveDown*djs[kcol];
	}
      }
      if (intVar[kcol])
	newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
      colUpper[kcol]=newUpper;
      columnGap[kcol] = newUpper-colLower[kcol]-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* down */
	if (value<0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveDown;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveDown;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rPos->rEnd
   } else if (doRowUpP) {
     // Start pos values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol =column[kk];
int markIt=markC[kcol];
if ((markIt&3)!=3) {
  double value2=rowElements[kk];
  assert (value2 > 0.0)(static_cast<void> (0));
  /* positive element */
  double gap = columnGap[kcol]*value2;
  bool doUp = (rowUp2 - gap < 0.0);
  if (doUp&&(markIt&(1+4))==0) {
    double newUpper=-1.0;
    double dbound = colLower[kcol] + rowUp2/value2;
    if (intVar[kcol]) {
      markIt |= 1;
      newUpper = floor(dbound+primalTolerance_);
    } else {
      newUpper=dbound;
      if (newUpper-primalTolerance_<colLower[kcol]&&
	  newUpper+primalTolerance_>=colLower[kcol]) {
	newUpper=colLower[kcol];
	markIt |= 1;
	//markIt=3;
      } else {
	// avoid problems - fix later ?
	markIt=3;
      }
    }
    double moveDown = newUpper-colUpper[kcol];
    if (!moveDown)
      continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newUpper<colsol[kcol]) {
	if (djs[kcol]>0.0) {
	  /* should be infeasible */
	  assert (colLower[kcol]>newUpper+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveDown*djs[kcol];
	}
      }
      if (intVar[kcol])
	newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
      colUpper[kcol]=newUpper;
      columnGap[kcol] = newUpper-colLower[kcol]-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* down */
	if (value<0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveDown;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveDown;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rPos->rEnd
   } else if (doRowLoP) {
     // Start pos values loop
     for (int kk =rStart;kk<rEnd;kk++) {
int kcol =column[kk];
if ((markC[kcol]&3)!=3) {
  double value2=rowElements[kk];
  int markIt=markC[kcol];
  assert (value2 > 0.0)(static_cast<void> (0));
  /* positive element */
  double gap = columnGap[kcol]*value2;
  bool doDown = (rowLo2 +gap > 0.0);
  if (doDown&&(markIt&(2+8))==0) {
    double newLower=1.0;
    double dbound = colUpper[kcol] + rowLo2/value2;
    if (intVar[kcol]) {
      markIt |= 2;
      newLower = ceil(dbound-primalTolerance_);
    } else {
      newLower=dbound;
      if (newLower+primalTolerance_>colUpper[kcol]&&
	  newLower-primalTolerance_<=colUpper[kcol]) {
	newLower=colUpper[kcol];
	markIt |= 2;
	//markIt=3;
      } else {
	// avoid problems - fix later ?
	markIt=3;
	}
    }
    double moveUp = newLower-colLower[kcol];
    if (!moveUp)
      continue;
    bool onList = ((markC[kcol]&3)!=0);
    if (nstackC<2*maxStack) {
      markC[kcol] = markIt;
    }
    if (nstackC<2*maxStack) {
      fixThis++;
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
	assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	assert (nstackC<nCols)(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newLower>colsol[kcol]) {
	if (djs[kcol]<0.0) {
	  /* should be infeasible */
	  assert (newLower>colUpper[kcol]+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveUp*djs[kcol];
	}
      }
      if (intVar[kcol]) 
	newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
      colLower[kcol]=newLower;
      columnGap[kcol] = colUpper[kcol]-newLower-primalTolerance_;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      markC[kcol] &= ~12;
      if (colUpper[kcol]>1.0e10)
	markC[kcol] |= 8;
      if (colLower[kcol]<-1.0e10)
	markC[kcol] |= 4;
      /* update immediately */
      for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	int krow = row[jj];
	double value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
	}
	/* could check immediately if violation */
	/* up */
	if (value>0.0) {
	  /* up does not change - down does */
	  if (minR[krow]>-1.0e10)
	    minR[krow] += value*moveUp;
	  if (krow==irow)
	    rowUp2 = rowUp-minR[irow];
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	} else {
	  /* down does not change - up does */
	  if (maxR[krow]<1.0e10)
	    maxR[krow] += value*moveUp;
	  if (krow==irow)
	    rowLo2 = rowLo-maxR[irow];
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    columnGap[kcol] = -1.0e50;
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
      break;
    }
  }
}
     } // end big loop rPos->rEnd
   }
        }
        istackC++;
      }
      if (!notFeasible) {
        if (objVal<=cutoff) {
          feasible |= feas[iway];
        } else {
4534#ifdef PRINT_DEBUG
          printf("not feasible on dj\n");
4536#endif
          notFeasible=1;
          if (iway==1&&feasible==0) {
            /* not feasible at all */
            ninfeas=1;
            j=nCols-1;
            break;
          }
        }
 if (!notFeasible&&saveFixingInfo) {
   // save fixing info
   assert (j==stackC[0])(static_cast<void> (0));
   int toValue = (way[iway]==1) ? -1 : +1;
   for (istackC=1;istackC<nstackC;istackC++) {
     int icol=stackC[istackC];
     // for now back to just 0-1
     if (colUpper[icol]-colLower[icol]<1.0e-12&&!saveL[istackC]&&saveU[istackC]==1.0) {
assert(saveL[istackC]==colLower[icol]||(static_cast<void> (0))
       saveU[istackC]==colUpper[icol])(static_cast<void> (0));
saveFixingInfo = info->fixes(j,toValue,
			     icol,colLower[icol]==saveL[istackC]);
     }
   }
 }
      } else if (iway==1&&feasible==0) {
        /* not feasible at all */
        ninfeas=1;
        j=nCols-1;
        iLook=numberThisTime_;
        ipass=maxPass;
        break;
      }
      if (notFeasible)
        goingToTrueBound=0;
      if (iway==2||(iway==1&&feasible==2)) {
        /* keep */
        iway=3;
        nfixed++;
        OsiColCut cc;
        int nTot=0,nFix=0,nInt=0;
        bool ifCut=false;
        for (istackC=0;istackC<nstackC;istackC++) {
          int icol=stackC[istackC];
          if (intVar[icol]) {
            if (colUpper[icol]<currentColUpper[icol]-1.0e-4) {
              element[nFix]=colUpper[icol];
              index[nFix++]=icol;
              nInt++;
              if (colsol[icol]>colUpper[icol]+primalTolerance_) {
                ifCut=true;
                anyColumnCuts=true;
              }
            }
          }
        }
        if (nFix) {
          nTot=nFix;
          cc.setUbs(nFix,index,element);
          nFix=0;
        }
        for (istackC=0;istackC<nstackC;istackC++) {
          int icol=stackC[istackC];
          if (intVar[icol]) {
            if (colLower[icol]>currentColLower[icol]+1.0e-4) {
              element[nFix]=colLower[icol];
              index[nFix++]=icol;
              nInt++;
              if (colsol[icol]<colLower[icol]-primalTolerance_) {
                ifCut=true;
                anyColumnCuts=true;
              }
            }
          }
        }
        if (nFix) {
          nTot+=nFix;
          cc.setLbs(nFix,index,element);
        }
        // could tighten continuous as well
        if (nInt) {
          if (ifCut) {
            cc.setEffectiveness(100.0);
          } else {
            cc.setEffectiveness(1.0e-5);
          }
4621#ifdef CGL_DEBUG
          checkBounds(debugger,cc);
4623#endif
          cs.insert(cc);
        }
        for (istackC=0;istackC<nstackC;istackC++) {
          int icol=stackC[istackC];
          if (colUpper[icol]-colLower[icol]>primalTolerance_) {
            markC[icol]&= ~3;
          } else {
            markC[icol]=3;
          }
        }
        for (istackR=0;istackR<nstackR;istackR++) {
          int irow=stackR[istackR];
          markR[irow]=-1;
        }
      } else {
        /* is it worth seeing if can increase coefficients
           or maybe better see if it is a cut */
        if (iway==0) {
          nstackC0=CoinMin(nstackC,maxStack);
          double solMove = saveSolval-down;
          double boundChange;
          if (notFeasible) {
            nstackC0=0;
          } else {
            for (istackC=0;istackC<nstackC0;istackC++) {
              int icol=stackC[istackC];
              stackC0[istackC]=icol;
              lo0[istackC]=colLower[icol];
              up0[istackC]=colUpper[icol];
            }
          }
          /* restore all */
          assert (iway==0)(static_cast<void> (0));
          for (istackC=nstackC-1;istackC>=0;istackC--) {
            int icol=stackC[istackC];
            double oldU=saveU[istackC];
            double oldL=saveL[istackC];
            if(goingToTrueBound==2&&istackC&&!justReplace) {
              // upper disaggregation cut would be
              // xval < upper + (old_upper-upper) (jval-down)
              boundChange = oldU-colUpper[icol];
              if (boundChange>0.0&&oldU<1.0e10&&
                  (colsol[icol]>colUpper[icol]
                   + boundChange*solMove+primalTolerance_)) {
                // create cut
                OsiRowCut rc;
                rc.setLb(-COIN_DBL_MAX);
                rc.setUb(colUpper[icol]-down*boundChange);
                index[0]=icol;
                element[0]=1.0;
                index[1]=j;
                element[1]= - boundChange;
                // effectiveness is how far j moves
                double newSol = (colsol[icol]-colUpper[icol])/
                  boundChange;
                assert(newSol>solMove)(static_cast<void> (0));
                rc.setEffectiveness(newSol-solMove);
                if (rc.effectiveness()>disaggEffectiveness) {
                  rc.setRow(2,index,element,false);
4683#ifdef CGL_DEBUG
                  if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
4685#endif
                  rowCut.addCutIfNotDuplicate(rc);
                }
              }
              // lower disaggregation cut would be
              // xval > lower + (old_lower-lower) (jval-down)
              boundChange = oldL-colLower[icol];
              if (boundChange<0.0&&oldL>-1.0e10&&
                  (colsol[icol]<colLower[icol]
                   + boundChange*solMove-primalTolerance_)) {
                // create cut
                OsiRowCut rc;
                rc.setLb(colLower[icol]-down*boundChange);
                rc.setUb(COIN_DBL_MAX);
                index[0]=icol;
                element[0]=1.0;
                index[1]=j;
                element[1]=- boundChange;
                // effectiveness is how far j moves
                double newSol = (colsol[icol]-colLower[icol])/
                  boundChange;
                assert(newSol>solMove)(static_cast<void> (0));
                rc.setEffectiveness(newSol-solMove);
                if (rc.effectiveness()>disaggEffectiveness) {
                  rc.setRow(2,index,element,false);
4710#ifdef CGL_DEBUG
                  if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
4712#endif
                  rowCut.addCutIfNotDuplicate(rc);
4714#if 0
                  printf("%d original bounds %g, %g new Lo %g sol= %g int %d sol= %g\n",icol,oldL,oldU,colLower[icol],colsol[icol], j, colsol[j]);
                  printf("-1.0 * x(%d) + %g * y(%d) <= %g\n",
                         icol,boundChange,j,rc.ub());
4718#endif
                }
              }
            }
            colUpper[icol]=oldU;
            colLower[icol]=oldL;
     columnGap[icol] = oldU-oldL-primalTolerance_;
            markC[icol]= 0;
     if (oldU>1.0e10)
markC[icol] |= 8;
     if (oldL<-1.0e10)
markC[icol] |= 4;
          }
          for (istackR=0;istackR<nstackR;istackR++) {
            int irow=stackR[istackR];
            // switch off strengthening if not wanted
            if ((rowCuts&2)!=0&&goingToTrueBound) {
              bool ifCut=anyColumnCuts;
              double gap = rowUpper[irow]-maxR[irow];
              double sum=0.0;
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                // also see if singletons can go to good objective
  // Taken out as should be found elsewhere
  // and has to be original column length
4743#ifdef MOVE_SINGLETONS
                bool moveSingletons=true;
4745#endif
                for (int kk =rowStart[irow];kk<rowStart[irow+1];
                     kk++) {
                  int iColumn = column[kk];
                  double value = rowElements[kk];
                  sum += value*colsol[iColumn];
4751#ifdef MOVE_SINGLETONS
                  if (moveSingletons&&j!=iColumn) {
                    if (colUpper[iColumn]>colLower[iColumn]) {
                      if (columnLength2[iColumn]!=1) {
                        moveSingletons=false;
                      }
                    }
                  }
4759#endif
                }
4761#ifdef MOVE_SINGLETONS
                if (moveSingletons) {
                  // can fix any with good costs
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                    int iColumn = column[kk];
                    if (j!=iColumn) {
                      if (colUpper[iColumn]>colLower[iColumn]) {
                        if (columnLength2[iColumn]==1) {
                          double value = rowElements[kk];
                          if (direction*objective[iColumn]*value<0.0&&!(markC[iColumn]&3)) {
                            // Fix
                            if (nstackC0+1<maxStack) {
                              stackC0[nstackC0]=iColumn;
                              if (value>0.0) {
                                lo0[nstackC0]=colUpper[iColumn];
                                up0[nstackC0]=colUpper[iColumn];
                              } else {
                                lo0[nstackC0]=colLower[iColumn];
                                up0[nstackC0]=colLower[iColumn];
                              }
                              nstackC0++;
                            }
                          }
                        }
                      }
                    }
                  }
                }
4790#endif
                if (sum-gap*colsol[j]>maxR[irow]+primalTolerance_||(info->strengthenRow&&rowLower[irow]<-1.0e20)) {
                  // can be a cut
                  // subtract gap from upper and integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
    double sum2=0.0;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
      int kColumn = column[kk];
      double el = rowElements[kk];
                    if (kColumn!=j) {
                      index[n]=kColumn;
                      element[n++]=el;
                    } else {
                      el=el-gap;
                      if (fabs(el)>1.0e-12) {
                        index[n]=kColumn;
                        element[n++]=el;
                      }
                      coefficientExists=true;
                    }
      sum2 += colsol[kColumn]*el;
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=-gap;
      sum2 -= colsol[j]*gap;
                  }
                  OsiRowCut rc;
                  rc.setLb(-COIN_DBL_MAX);
    double ub =rowUpper[irow]-gap*(colLower[j]+1.0);
                  rc.setUb(ub);
                  double effectiveness=sum2-ub;
                  effectiveness = CoinMax(effectiveness,
			    (sum-gap*colsol[j]
			     -maxR[irow])/gap);
    if (!coefficientExists)
      effectiveness=CoinMax(1.0e-7,
			    effectiveness);
                  rc.setEffectiveness(effectiveness);
                  //rc.setEffectiveness((sum-gap*colsol[j]-maxR[irow])/gap);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
4837#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
4839#endif
                    // If strengthenRow point to row
                    //if(info->strengthenRow)
                    //printf("a point to row %d\n",irow);
      //#define STRENGTHEN_PRINT
4844#ifdef STRENGTHEN_PRINT
      if (canReplace&&rowLower[irow]<-1.0e20) {
	printf("1Cut %g <= ",rc.lb());
	int k;
	//printf("original row %d - %g <= <= %g - j = %d\n",iow,rowLower[irow],rowUpper[irow],j);
	//for (int kk=rowStart[irow];kk<rowStart[irow+1];kk++) 
	//printf("(%d,%g) ",column[kk],rowElements[kk]);
	//printf("\n");
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow+1];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
4872#endif
      int realRow = (canReplace&&rowLower[irow]<-1.0e20) ? irow : -1;
      if (realRows&&realRow>=0)
	realRow=realRows[realRow];
      if (!justReplace) {
	rowCut.addCutIfNotDuplicate(rc,realRow);
      } else if (realRow>=0) {
	double effectiveness=0.0;
	for (int i=0;i<n;i++)
	  effectiveness+=fabs(element[i]);
	if (!info->strengthenRow[realRow]||info->strengthenRow[realRow]->effectiveness()>effectiveness) {
	  delete info->strengthenRow[realRow];
	  rc.setEffectiveness(effectiveness);
	  info->strengthenRow[realRow]=rc.clone();
	}
      }
                  }
                }
              }
              gap = minR[irow]-rowLower[irow];
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                sum =0.0;
                // also see if singletons can go to good objective
4896#ifdef MOVE_SINGLETONS
                bool moveSingletons=true;
4898#endif
                for (int kk =rowStart[irow];kk<rowStart[irow+1];
                     kk++) {
                  int iColumn = column[kk];
                  double value = rowElements[kk];
                  sum += value*colsol[iColumn];
4904#ifdef MOVE_SINGLETONS
                  if (moveSingletons&&j!=iColumn) {
                    if (colUpper[iColumn]>colLower[iColumn]) {
                      if (columnLength2[iColumn]!=1) {
                        moveSingletons=false;
                      }
                    }
                  }
4912#endif
                }
4914#ifdef MOVE_SINGLETONS
                if (moveSingletons) {
                  // can fix any with good costs
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                    int iColumn = column[kk];
                    if (j!=iColumn) {
                      if (colUpper[iColumn]>colLower[iColumn]) {
                        if (columnLength2[iColumn]==1) {
                          double value = rowElements[kk];
                          if (direction*objective[iColumn]*value>0.0&&!(markC[iColumn]&3)) {
                            // Fix
                            if (nstackC0+1<maxStack) {
                              stackC0[nstackC0]=iColumn;
                              if (value<0.0) {
                                lo0[nstackC0]=colUpper[iColumn];
                                up0[nstackC0]=colUpper[iColumn];
                              } else {
                                lo0[nstackC0]=colLower[iColumn];
                                up0[nstackC0]=colLower[iColumn];
                              }
                              nstackC0++;
                            }
                          }
                        }
                      }
                    }
                  }
                }
4943#endif
                if (sum+gap*colsol[j]<minR[irow]-primalTolerance_||(info->strengthenRow&&rowUpper[irow]>1.0e20)) {
                  // can be a cut
                  // add gap to lower and integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
    double sum2=0.0;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
      int kColumn = column[kk];
      double el = rowElements[kk];
                    if (kColumn!=j) {
                      index[n]=kColumn;
                      element[n++]=el;
                    } else {
                      el=el+gap;
                      if (fabs(el)>1.0e-12) {
                        index[n]=kColumn;
                        element[n++]=el;
                      }
                      coefficientExists=true;
                    }
      sum2 += colsol[kColumn]*el;
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=gap;
      sum2 += colsol[j]*gap;
                  }
                  OsiRowCut rc;
    double lb = rowLower[irow]+gap*(colLower[j]+1.0);
                  rc.setLb(lb);
                  rc.setUb(COIN_DBL_MAX);
                  // effectiveness
                  double effectiveness=lb-sum2;
                  effectiveness = CoinMax(effectiveness,
			    (minR[irow]-
			     sum-gap*colsol[j])/gap);
    if (!coefficientExists)
      effectiveness=CoinMax(1.0e-7,
			    effectiveness);
                  rc.setEffectiveness(effectiveness);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
4990#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
4992#endif
                    //if(info->strengthenRow)
                    //printf("b point to row %d\n",irow);
4995#ifdef STRENGTHEN_PRINT
      if (canReplace&&rowUpper[irow]>1.0e20) {
	printf("2Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow+1];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
5019#endif
      int realRow = (canReplace&&rowUpper[irow]>1.0e20) ? irow : -1;
      if (realRows&&realRow>=0)
	realRow=realRows[realRow];
      if (!justReplace) {
	rowCut.addCutIfNotDuplicate(rc,realRow);
      } else if (realRow>=0) {
	double effectiveness=0.0;
	for (int i=0;i<n;i++)
	  effectiveness+=fabs(element[i]);
	if (!info->strengthenRow[realRow]||info->strengthenRow[realRow]->effectiveness()>effectiveness) {
	  delete info->strengthenRow[realRow];
	  rc.setEffectiveness(effectiveness);
	  info->strengthenRow[realRow]=rc.clone();
	}
      }
                  }
                }
              }
            }
            minR[irow]=saveMin[istackR];
            maxR[irow]=saveMax[istackR];
            markR[irow]=-1;
          }
        } else {
          if (iway==1&&feasible==3) {
            iway=3;
5046#ifdef MOVE_SINGLETONS
            // look for singletons that can move (just at root)
            if ((rowCuts&2)!=0&&goingToTrueBound&&info->strengthenRow) {
              for (istackR=0;istackR<nstackR;istackR++) {
                int irow=stackR[istackR];
                double gap = rowUpper[irow]-maxR[irow];
                if (gap>primalTolerance_) {
                  // also see if singletons can go to good objective
                  bool moveSingletons=true;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                    int iColumn = column[kk];
                    if (moveSingletons&&j!=iColumn) {
                      if (colUpper[iColumn]>colLower[iColumn]) {
                        if (columnLength2[iColumn]!=1) {
                          moveSingletons=false;
                        }
                      }
                    }
                  }
                  if (moveSingletons) {
                    // can fix any with good costs
                    for (int kk =rowStart[irow];kk<rowStart[irow+1];
                         kk++) {
                      int iColumn = column[kk];
                      if (j!=iColumn) {
                        if (colUpper[iColumn]>colLower[iColumn]) {
                          if (columnLength2[iColumn]==1) {
                            double value = rowElements[kk];
                            if (direction*objective[iColumn]*value<0.0&&!(markC[iColumn]&3)) {
                              // Fix
                              stackC[nstackC]=iColumn;
                              saveL[nstackC]=colLower[iColumn];
                              saveU[nstackC]=colUpper[iColumn];
                              assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                              if (value>0.0) {
                                colLower[iColumn]=colUpper[iColumn];
                              } else {
                                colUpper[iColumn]=colLower[iColumn];
                              }
		columnGap[iColumn] = -primalTolerance_;
                              assert (nstackC<nCols)(static_cast<void> (0));
                              nstackC++;
                            }
                          }
                        }
                      }
                    }
                  }
                }
                gap = minR[irow]-rowLower[irow];
                if (gap>primalTolerance_) {
                  // also see if singletons can go to good objective
                  bool moveSingletons=true;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                    int iColumn = column[kk];
                    if (moveSingletons&&j!=iColumn) {
                      if (colUpper[iColumn]>colLower[iColumn]) {
                        if (columnLength2[iColumn]!=1) {
                          moveSingletons=false;
                        }
                      }
                    }
                  }
                  if (moveSingletons) {
                    // can fix any with good costs
                    for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                      int iColumn = column[kk];
                      if (j!=iColumn) {
                        if (colUpper[iColumn]>colLower[iColumn]) {
                          if (columnLength2[iColumn]==1) {
                            double value = rowElements[kk];
                            if (direction*objective[iColumn]*value>0.0&&!(markC[iColumn]&3)) {
                              // Fix
                              stackC[nstackC]=iColumn;
                              saveL[nstackC]=colLower[iColumn];
                              saveU[nstackC]=colUpper[iColumn];
                              assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                              if (value<0.0) {
                                colLower[iColumn]=colUpper[iColumn];
                              } else {
                                colUpper[iColumn]=colLower[iColumn];
                              }
		columnGap[iColumn] = -primalTolerance_;
                              assert (nstackC<nCols)(static_cast<void> (0));
                              nstackC++;
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
5143#endif
            /* point back to stack */
            for (istackC=nstackC-1;istackC>=0;istackC--) {
              int icol=stackC[istackC];
              markC[icol]=istackC+1000;
            }
            OsiColCut cc;
            int nTot=0,nFix=0,nInt=0;
            bool ifCut=false;
            for (istackC=1;istackC<nstackC0;istackC++) {
              int icol=stackC0[istackC];
              int istackC1=markC[icol]-1000;
              if (istackC1>=0) {
                if (CoinMin(lo0[istackC],colLower[icol])>saveL[istackC1]+1.0e-4) {
                  saveL[istackC1]=CoinMin(lo0[istackC],colLower[icol]);
                  if (intVar[icol]/*||!info->inTree*/) {
                    element[nFix]=saveL[istackC1];
                    index[nFix++]=icol;
                    nInt++;
                    if (colsol[icol]<saveL[istackC1]-primalTolerance_)
                      ifCut=true;
                  }
                  nfixed++;
                } 
              }
            }
            if (nFix) {
              nTot=nFix;
              cc.setLbs(nFix,index,element);
              nFix=0;
            }
            for (istackC=1;istackC<nstackC0;istackC++) {
              int icol=stackC0[istackC];
              int istackC1=markC[icol]-1000;
              if (istackC1>=0) {
                if (CoinMax(up0[istackC],colUpper[icol])<saveU[istackC1]-1.0e-4) {
                  saveU[istackC1]=CoinMax(up0[istackC],colUpper[icol]);
                  if (intVar[icol]/*||!info->inTree*/) {
                    element[nFix]=saveU[istackC1];
                    index[nFix++]=icol;
                    nInt++;
                    if (colsol[icol]>saveU[istackC1]+primalTolerance_)
                      ifCut=true;
                  }
                  nfixed++;
                } else if (!info->inTree&&saveL[0]==0.0&&saveU[0]==1.0) {
                  // See if can do two cut
                  double upperWhenDown = up0[istackC];
                  double lowerWhenDown = lo0[istackC];
                  double upperWhenUp = colUpper[icol];
                  double lowerWhenUp = colLower[icol];
                  double upperOriginal = saveU[istackC1];
                  double lowerOriginal = saveL[istackC1];
                  if (upperWhenDown<lowerOriginal+1.0e-12&&lowerWhenUp>upperOriginal-1.0e-12) {
                    OsiRowCut rc;
                    rc.setLb(lowerOriginal);
                    rc.setUb(lowerOriginal);
                    rc.setEffectiveness(1.0e-5);
                    int index[2];
                    double element[2];
                    index[0]=j;
                    index[1]=icol;
                    element[0]=-(upperOriginal-lowerOriginal);
      // If zero then - must have been fixed without noticing!
      if (fabs(element[0])>1.0e-8) {
	element[1]=1.0;
	rc.setRow(2,index,element,false);
	cs.insert(rc);
      }
                  } else if (upperWhenUp<lowerOriginal+1.0e-12&&lowerWhenDown>upperOriginal-1.0e-12) {
                    OsiRowCut rc;
                    rc.setLb(upperOriginal);
                    rc.setUb(upperOriginal);
                    rc.setEffectiveness(1.0e-5);
                    int index[2];
                    double element[2];
                    index[0]=j;
                    index[1]=icol;
                    element[0]=upperOriginal-lowerOriginal;
                    element[1]=1.0;
                    rc.setRow(2,index,element,false);
                    cs.insert(rc);
                  } 
                }
              }
            }
            if (nFix) {
              nTot+=nFix;
              cc.setUbs(nFix,index,element);
            }
            // could tighten continuous as well
            if (nInt) {
              if (ifCut) {
                cc.setEffectiveness(100.0);
              } else {
                cc.setEffectiveness(1.0e-5);
              }
5240#ifdef CGL_DEBUG
              checkBounds(debugger,cc);
5242#endif
              cs.insert(cc);
            }
          } else {
            goingToTrueBound=0;
          }
          double solMove = up-saveSolval;
          double boundChange;
          /* restore all */
          for (istackC=nstackC-1;istackC>=0;istackC--) {
            int icol=stackC[istackC];
            double oldU=saveU[istackC];
            double oldL=saveL[istackC];
            if(goingToTrueBound==2&&istackC&&!justReplace) {
              // upper disaggregation cut would be
              // xval < upper + (old_upper-upper) (up-jval)
              boundChange = oldU-colUpper[icol];
              if (boundChange>0.0&&oldU<1.0e10&&
                  (colsol[icol]>colUpper[icol]
                   + boundChange*solMove+primalTolerance_)) {
                // create cut
                OsiRowCut rc;
                rc.setLb(-COIN_DBL_MAX);
                rc.setUb(colUpper[icol]+up*boundChange);
                index[0]=icol;
                element[0]=1.0;
                index[1]=j;
                element[1]= + boundChange;
                // effectiveness is how far j moves
                double newSol = (colsol[icol]-colUpper[icol])/
                  boundChange;
                assert(newSol>solMove)(static_cast<void> (0));
                rc.setEffectiveness(newSol-solMove);
                if (rc.effectiveness()>disaggEffectiveness) {
                  rc.setRow(2,index,element,false);
5277#ifdef CGL_DEBUG
                  if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
5279#endif
                  rowCut.addCutIfNotDuplicate(rc);
                }
              }
              // lower disaggregation cut would be
              // xval > lower + (old_lower-lower) (up-jval)
              boundChange = oldL-colLower[icol];
              if (boundChange<0.0&&oldL>-1.0e10&&
                  (colsol[icol]<colLower[icol]
                   + boundChange*solMove-primalTolerance_)) {
                // create cut
                OsiRowCut rc;
                rc.setLb(colLower[icol]+up*boundChange);
                rc.setUb(COIN_DBL_MAX);
                index[0]=icol;
                element[0]=1.0;
                index[1]=j;
                element[1]= + boundChange;
                // effectiveness is how far j moves
                double newSol = (colsol[icol]-colLower[icol])/
                  boundChange;
                assert(newSol>solMove)(static_cast<void> (0));
                rc.setEffectiveness(newSol-solMove);
                if (rc.effectiveness()>disaggEffectiveness) {
                  rc.setRow(2,index,element,false);
5304#ifdef CGL_DEBUG
                  if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
5306#endif
                  rowCut.addCutIfNotDuplicate(rc);
                }
              }
            }
            colUpper[icol]=oldU;
            colLower[icol]=oldL;
     columnGap[icol] = oldU-oldL-primalTolerance_;
            if (oldU>oldL+1.0e-4) {
              markC[icol]=0;
if (oldU>1.0e10)
  markC[icol] |= 8;
if (oldL<-1.0e10)
  markC[icol] |= 4;
            } else {
              markC[icol]=3;
     }
          }
          for (istackR=0;istackR<nstackR;istackR++) {
            int irow=stackR[istackR];
            // switch off strengthening if not wanted
            if ((rowCuts&2)!=0&&goingToTrueBound) {
bool canReplace = info->strengthenRow&&(goingToTrueBound==2);
              bool ifCut=anyColumnCuts;
              double gap = rowUpper[irow]-maxR[irow];
              double sum=0.0;
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                for (int kk =rowStart[irow];kk<rowStart[irow+1];
                     kk++) {
                  sum += rowElements[kk]*colsol[column[kk]];
                }
                if (sum+gap*colsol[j]>rowUpper[irow]+primalTolerance_||(canReplace&&rowLower[irow]<-1.e20)) {
                  // can be a cut
                  // add gap to integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
    double sum2=0.0;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
      int kColumn = column[kk];
      double el = rowElements[kk];
                    if (kColumn!=j) {
                      index[n]=kColumn;
                      element[n++]=el;
                    } else {
                      el=el+gap;
                      if (fabs(el)>1.0e-12) {
                        index[n]=kColumn;
                        element[n++]=el;
                      }
                      coefficientExists=true;
                    }
      sum2 += colsol[kColumn]*el;
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=gap;
      sum2 += colsol[j]*gap;
                  }
                  OsiRowCut rc;
                  rc.setLb(-COIN_DBL_MAX);
    double ub = rowUpper[irow]+gap*(colUpper[j]-1.0);
                  rc.setUb(ub);
                  // effectiveness
                  double effectiveness=sum2-ub;
                  effectiveness = CoinMax(effectiveness,
			    (sum+gap*colsol[j]-
			     rowUpper[irow])/gap);
    if (!coefficientExists)
      effectiveness=CoinMax(1.0e-7,
			    effectiveness);
                  rc.setEffectiveness(effectiveness);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
5384#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
5386#endif
                    //if(canReplace)
                    //printf("c point to row %d\n",irow);
5389#ifdef STRENGTHEN_PRINT
      if (canReplace&&rowLower[irow]<-1.0e20) {
	printf("3Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow+1];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
5413#endif
      int realRow = (canReplace&&rowLower[irow]<-1.0e20) ? irow : -1;
      if (realRows&&realRow>=0)
	realRow=realRows[realRow];
      if (!justReplace) {
	rowCut.addCutIfNotDuplicate(rc,realRow);
      } else if (realRow>=0) {
	double effectiveness=0.0;
	for (int i=0;i<n;i++)
	  effectiveness+=fabs(element[i]);
	if (!info->strengthenRow[realRow]||info->strengthenRow[realRow]->effectiveness()>effectiveness) {
	  delete info->strengthenRow[realRow];
	  rc.setEffectiveness(effectiveness);
	  info->strengthenRow[realRow]=rc.clone();
	}
      }
                  }
                }
              }
              gap = minR[irow]-rowLower[irow];
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                if (!sum) {
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
                    sum += rowElements[kk]*colsol[column[kk]];
                  }
                }
                if (sum-gap*colsol[j]<rowLower[irow]-primalTolerance_||(canReplace&&rowUpper[irow]>1.0e20)) {
                  // can be a cut
                  // subtract gap from integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
    double sum2=0.0;
                  for (int kk =rowStart[irow];kk<rowStart[irow+1];
                       kk++) {
      int kColumn = column[kk];
      double el = rowElements[kk];
                    if (kColumn!=j) {
                      index[n]=kColumn;
                      element[n++]=el;
                    } else {
                      el=el-gap;
                      if (fabs(el)>1.0e-12) {
                        index[n]=kColumn;
                        element[n++]=el;
                      }
                      coefficientExists=true;
                    }
      sum2 += colsol[kColumn]*el;
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=-gap;
      sum2 -= colsol[j]*gap;
                  }
                  OsiRowCut rc;
                  double lb = rowLower[irow]-gap*(colUpper[j]-1);
                  rc.setLb(lb);
                  rc.setUb(COIN_DBL_MAX);
    double effectiveness=lb-sum2;
                  effectiveness = CoinMax(effectiveness,
			    (rowLower[irow]-
			     sum+gap*colsol[j])/gap);
    if (!coefficientExists)
      effectiveness=CoinMax(1.0e-7,
			    effectiveness);
                  rc.setEffectiveness(effectiveness);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
5486#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
5488#endif
                    //if(canReplace)
                    //printf("d point to row %d\n",irow);
5491#ifdef STRENGTHEN_PRINT
      if (canReplace&&rowUpper[irow]>1.0e20) {
	printf("4Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow+1];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
5515#endif
      int realRow = (canReplace&&rowUpper[irow]>1.0e20) ? irow : -1;
      if (realRows&&realRow>=0)
	realRow=realRows[realRow];
      if (!justReplace) {
	rowCut.addCutIfNotDuplicate(rc,realRow);
      } else if (realRow>=0) {
	double effectiveness=0.0;
	for (int i=0;i<n;i++)
	  effectiveness+=fabs(element[i]);
	if (!info->strengthenRow[realRow]||info->strengthenRow[realRow]->effectiveness()>effectiveness) {
	  delete info->strengthenRow[realRow];
	  rc.setEffectiveness(effectiveness);
	  info->strengthenRow[realRow]=rc.clone();
	}
      }
                  }
                }
              }
            }
            minR[irow]=saveMin[istackR];
            maxR[irow]=saveMax[istackR];
            markR[irow]=-1;
          }
        }
      }
    }
  }
}
if ((!ninfeas&&!rowCut.outOfSpace())&&(info->strengthenRow||
               !rowCut.numberCuts())&&rowCuts) {
  // Try and find ALL big M's
  for (int i = 0; i < nRowsSafe; ++i) {
    if ((rowLower[i]>-1.0e20||rowUpper[i]<1.0e20)&&
        (!info->strengthenRow||!info->strengthenRow[i])) {
int iflagu = 0;
int iflagl = 0;
double dmaxup = 0.0;
double dmaxdown = 0.0;
int krs = rowStart[i];
int kre = rowStart[i+1];
      int kInt = -1;
double rhsAdjustment=0.0;
int nPosInt=0;
int nNegInt=0;
      double valueInteger=0.0;
      // Find largest integer coefficient
int k;
      for ( k = krs; k < kre; ++k) {
        int j = column[k];
        if (intVar[j]) {
          double value=rowElements[k];
          if (colUpper[j]>colLower[j]&&!colLower[j]&&
              fabs(value)>fabs(valueInteger)) {
            kInt=j;
            valueInteger=value;
          }
        }
      }
      if (kInt>=0) {
        double upperBound = CoinMin(colUpper[kInt],static_cast<double>(COIN_INT_MAX));
 double upAdjust=0.0;
 double downAdjust=0.0;
        for (k = krs; k < kre; ++k) {
          double value=rowElements[k];
          int j = column[k];
          if (colUpper[j]==colLower[j]) {
     rhsAdjustment += colUpper[j]*value;
            continue;
          }
   if (intVar[j]) {
     if (value>0.0)
nPosInt++;
     else
nNegInt++;
   } else {
     nPosInt = -nCols;
   }
          if (j!=kInt) {
            // treat as continuous
            if (value > 0.0) {
              if (colUpper[j] >= 1e15) {
                dmaxup = 1e31;
                ++iflagu;
              } else {
                dmaxup += colUpper[j] * value;
              }
              if (colLower[j] <= -1e15) {
                dmaxdown = -1e31;
                ++iflagl;
              } else {
                dmaxdown += colLower[j] * value;
              }
            } else if (value<0.0) {
              if (colUpper[j] >= 1e15) {
                dmaxdown = -1e31;
                ++iflagl;
              } else {
                dmaxdown += colUpper[j] * value;
              }
              if (colLower[j] <= -1e15) {
                dmaxup = 1e31;
                ++iflagu;
              } else {
                dmaxup += colLower[j] * value;
              }
            }
   } else {
            // Chosen variable
            if (value > 0.0) {
              if (colUpper[j] >= 1e15) {
                upAdjust = 1e31;
              } else {
                upAdjust = colUpper[j] * value;
              }
              if (colLower[j] <= -1e15) {
                downAdjust = -1e31;
              } else {
                downAdjust = colLower[j] * value;
              }
            } else if (value<0.0) {
              if (colUpper[j] >= 1e15) {
                downAdjust = -1e31;
              } else {
                downAdjust = colUpper[j] * value;
              }
              if (colLower[j] <= -1e15) {
                upAdjust = 1e31;
              } else {
                upAdjust = colLower[j] * value;
              }
            }
          }
        }
 dmaxup += rhsAdjustment;
 dmaxdown += rhsAdjustment;
        // end of row
        if (iflagu)
          dmaxup=1.0e31;
        if (iflagl)
          dmaxdown=-1.0e31;
 // See if redundant
 if (dmaxdown+downAdjust>rowLower[i]-tolerance&&
     dmaxup+upAdjust<rowUpper[i]+tolerance) 
   continue;
        if (dmaxdown+valueInteger*upperBound>rowLower[i]&&
            dmaxup+valueInteger*upperBound<rowUpper[i]) {
          // check to see if always feasible at 1 but not always at 0
          if (dmaxdown+valueInteger>rowLower[i]&&dmaxup+valueInteger<rowUpper[i]&&
              (dmaxdown<rowLower[i]-primalTolerance_||dmaxup>rowUpper[i]+primalTolerance_)) {
            // can tighten (maybe)
            double saveValue = valueInteger;
            if (valueInteger>0.0) {
              assert (dmaxdown<rowLower[i])(static_cast<void> (0));
              valueInteger = rowLower[i]-dmaxdown;
            } else {
              assert (dmaxup>rowUpper[i])(static_cast<void> (0));
              valueInteger = rowUpper[i]-dmaxup;
            }
            if (fabs(saveValue-valueInteger)>1.0e-12) {
              // take
              OsiRowCut rc;
              rc.setLb(rowLower[i]);
              rc.setUb(rowUpper[i]);
              int n=0;
              double sum=0.0;
              for (int kk=rowStart[i];kk<rowStart[i+1];kk++) {
                int j=column[kk];
                if (j!=kInt) {
                  sum += colsol[j]*rowElements[kk];
                  index[n]=j;
                  element[n++]=rowElements[kk];
                } else {
                  sum += colsol[j]*valueInteger;
                  assert (rowElements[kk]*valueInteger>=0.0)(static_cast<void> (0));
5690#if 0
                  if (fabs(rowElements[kk])>1.01*fabs(valueInteger)) {
                    printf("row %d changing coefficient of %d from %g to %g\n",
                           i,kInt,rowElements[kk],valueInteger);
                  }
5695#endif
                  if (fabs(valueInteger)>1.0e-12) {
                    index[n]=column[kk];
                    element[n++]=valueInteger;
                  }
                }
              }
              double gap = 0.0;
              if (sum<rowLower[i])
                gap=rowLower[i]-sum;
              else if (sum>rowUpper[i])
                gap=sum-rowUpper[i];
              if (gap>1.0e-4||info->strengthenRow!=NULL__null) {
  gap += 1.0e5;
                rc.setEffectiveness(gap);
                rc.setRow(n,index,element,false);
5711#ifdef STRENGTHEN_PRINT
  {
    printf("1aCut %g <= ",rc.lb());
    int irow =i;
    int k;
    for ( k=0;k<n;k++) {
      int iColumn = index[k];
      printf("%g*",element[k]);
      if (si.isInteger(iColumn))
	printf("i%d ",iColumn);
      else
	printf("x%d ",iColumn);
    }
    printf("<= %g\n",rc.ub());
    printf("Row %g <= ",rowLower[irow]);
    for (k=rowStart[irow];k<rowStart[irow+1];k++) {
      int iColumn = column[k];
      printf("%g*",rowElements[k]);
      if (si.isInteger(iColumn))
	printf("i%d ",iColumn);
      else
	printf("x%d ",iColumn);
    }
    printf("<= %g\n",rowUpper[irow]);
  }
5736#endif
                int returnCode=rowCut.addCutIfNotDuplicate(rc,i);
                if (returnCode<0)
                  break; // out of space
              }
            }
          }
        }
      }
    }
  }
}
5748#ifndef ONE_ARRAY
delete [] stackC0;
delete [] lo0;
delete [] up0;
delete [] columnGap;
delete [] markC;
delete [] stackC;
delete [] stackR;
delete [] saveL;
delete [] saveU;
delete [] saveMin;
delete [] saveMax;
delete [] index;
delete [] element;
delete [] djs;
delete [] largestPositiveInRow;
delete [] largestNegativeInRow;
5765#endif
delete [] colsol;
// Add in row cuts
if (!ninfeas) {
  if (!justReplace) {
    rowCut.addCuts(cs,info->strengthenRow,info->pass);
  } else {
    for (int i=0;i<nRows;i++) {
int realRow=realRows[i];
if (realRow>=0) {
 OsiRowCut * cut = info->strengthenRow[realRow];
 if (cut) {
5777#ifdef CLP_INVESTIGATE
   printf("Row %d, real row %d effectiveness %g\n",i,realRow,cut->effectiveness());
5779#endif
   cs.insert(cut);
 }
}
    }
  }
}
5786#if 0
{
  int numberRowCutsAfter = cs.sizeRowCuts() ;
  int k ;
  for (k = 0;k<numberRowCutsAfter;k++) {
    OsiRowCut thisCut = cs.rowCut(k) ;
    printf("Cut %d is %g <=",k,thisCut.lb());
    int n=thisCut.row().getNumElements();
    const int * column = thisCut.row().getIndices();
    const double * element = thisCut.row().getElements();
    assert (n)(static_cast<void> (0));
    for (int i=0;i<n;i++) {
printf(" %g*x%d",element[i],column[i]);
    }
    printf(" <= %g\n",thisCut.ub());
  }
}
5803#endif
return (ninfeas);
5805}
5806// Does probing and adding cuts
5807int CglProbing::probeCliques( const OsiSolverInterface & si, 
                            const OsiRowCutDebugger *
5809#ifdef CGL_DEBUG
	 debugger
5811#endif
                            ,OsiCuts & cs, 
                            double * colLower, double * colUpper, 
       CoinPackedMatrix *rowCopy,
	      CoinPackedMatrix *columnCopy, const int * realRows,
       double * rowLower, double * rowUpper,
       char * intVar, double * minR, double * maxR, 
       int * markR, 
                     CglTreeInfo * info)
5820{
// Set up maxes
int maxStack = info->inTree ? maxStack_ : maxStackRoot_;
int nRows=rowCopy->getNumRows();
int nCols=rowCopy->getNumCols();
double * colsol = new double[nCols];
double * djs = new double[nCols];
const double * currentColLower = si.getColLower();
const double * currentColUpper = si.getColUpper();
double * tempL = new double [nCols];
double * tempU = new double [nCols];
int * markC = new int [nCols];
int * stackC = new int [2*nCols];
int * stackR = new int [nRows];
double * saveL = new double [2*nCols];
double * saveU = new double [2*nCols];
double * saveMin = new double [nRows];
double * saveMax = new double [nRows];
double * element = new double[nCols];
int * index = new int[nCols];
// For trying to extend cliques
int * cliqueStack=NULL__null;
int * cliqueCount=NULL__null;
int * to_01=NULL__null;
if (!mode_) {
  to_01 = new int[nCols];
  cliqueStack = new int[numberCliques_];
  cliqueCount = new int[numberCliques_];
  int i;
  for (i=0;i<numberCliques_;i++) {
    cliqueCount[i]=cliqueStart_[i+1]-cliqueStart_[i];
  }
  for (i=0;i<nCols;i++) 
    to_01[i]=-1;
  for (i=0;i<number01Integers_;i++) {
    int j=cutVector_[i].sequence;
    to_01[j]=i;
  }
}
// Let us never add more than twice the number of rows worth of row cuts
// Keep cuts out of cs until end so we can find duplicates quickly
int nRowsFake = info->inTree ? nRows/3 : nRows;
row_cut rowCut(nRowsFake, !info->inTree);
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths(); 
const double * rowElements = rowCopy->getElements();
const int * row = columnCopy->getIndices();
const CoinBigIndex * columnStart = columnCopy->getVectorStarts();
const int * columnLength = columnCopy->getVectorLengths(); 
const double * columnElements = columnCopy->getElements();
double movement;
int i, j, k,kk,jj;
int kcol,krow;
bool anyColumnCuts=false;
double dbound, value, value2;
int ninfeas=0;
int rowCuts;
double disaggEffectiveness;
if (mode_) {
  /* clean up djs and solution */
  CoinMemcpyN(si.getReducedCost(),nCols,djs);
  CoinMemcpyN( si.getColSolution(),nCols,colsol);
  disaggEffectiveness=1.0e-3;
  rowCuts=rowCuts_;
} else {
  // need to go from a neutral place
  memset(djs,0,nCols*sizeof(double));
  CoinMemcpyN( si.getColSolution(),nCols,colsol);
  disaggEffectiveness=-1.0e10;
  if (rowCuts_!=4)
    rowCuts=1;
  else
    rowCuts=4;
}
for (i = 0; i < nCols; ++i) {
  /* was if (intVar[i]) */
  if (1) {
    if (colUpper[i]-colLower[i]>1.0e-8) {
if (colsol[i]<colLower[i]+primalTolerance_) {
 colsol[i]=colLower[i];
 djs[i] = CoinMax(0.0,djs[i]);
} else if (colsol[i]>colUpper[i]-primalTolerance_) {
 colsol[i]=colUpper[i];
 djs[i] = CoinMin(0.0,djs[i]);
} else {
 djs[i]=0.0;
}
/*if (fabs(djs[i])<1.0e-5) 
 djs[i]=0.0;*/
    }
  }
}

int ipass=0,nfixed=-1;

double cutoff;
bool cutoff_available = si.getDblParam(OsiDualObjectiveLimit,cutoff);
if (!cutoff_available||usingObjective_<0) { // cut off isn't set or isn't valid
  cutoff = si.getInfinity();
}
cutoff *= si.getObjSense();
if (fabs(cutoff)>1.0e30)
  assert (cutoff>1.0e30)(static_cast<void> (0));
double current = si.getObjValue();
// make irrelevant if mode is 0
if (!mode_)
  cutoff=COIN_DBL_MAX;
/* for both way coding */
int nstackC0=-1;
int * stackC0 = new int[maxStack];
double * lo0 = new double[maxStack];
double * up0 = new double[maxStack];
int nstackR,nstackC;
for (i=0;i<nCols;i++) {
  if (colUpper[i]-colLower[i]<1.0e-8) {
    markC[i]=3;
  } else {
    markC[i]=0;
  }
}
double tolerance = 1.0e1*primalTolerance_;
int maxPass = info->inTree ? maxPass_ : maxPassRoot_;
// If we are going to replace coefficient then we don't need to be effective
double needEffectiveness = info->strengthenRow ? -1.0e10 : 1.0e-3;
while (ipass<maxPass&&nfixed) {
  int iLook;
  ipass++;
  nfixed=0;
  for (iLook=0;iLook<numberThisTime_;iLook++) {
    double solval;
    double down;
    double up;
    j=lookedAt_[iLook];
    solval=colsol[j];
    down = floor(solval+tolerance);
    up = ceil(solval-tolerance);
    if(colUpper[j]-colLower[j]<1.0e-8) markC[j]=3;
    if (markC[j]||!intVar[j]) continue;
    double saveSolval = solval;
    if (solval>=colUpper[j]-tolerance||solval<=colLower[j]+tolerance||up==down) {
if (solval<=colLower[j]+2.0*tolerance) {
 solval = colLower[j]+1.0e-1;
 down=colLower[j];
 up=down+1.0;
} else if (solval>=colUpper[j]-2.0*tolerance) {
 solval = colUpper[j]-1.0e-1;
 up=colUpper[j];
 down=up-1;
} else {
        // odd
        up=down+1.0;
        solval = down+1.0e-1;
      }
    }
    assert (up<=colUpper[j])(static_cast<void> (0));
    assert (down>=colLower[j])(static_cast<void> (0));
    assert (up>down)(static_cast<void> (0));
    if ((solval-down>1.0e-6&&up-solval>1.0e-6)||mode_!=1) {
int istackC,iway, istackR;
int way[]={1,2,1};
int feas[]={1,2,4};
int feasible=0;
int notFeasible;
for (iway=0;iway<3;iway ++) {
 int fixThis=0;
 double objVal=current;
 int goingToTrueBound=0;
 stackC[0]=j;
 markC[j]=way[iway];
        double solMovement;
 if (way[iway]==1) {
   movement=down-colUpper[j];
          solMovement = down-colsol[j];
   assert(movement<-0.99999)(static_cast<void> (0));
   if (fabs(down-colLower[j])<1.0e-7) {
     goingToTrueBound=2;
     down=colLower[j];
   }
 } else {
   movement=up-colLower[j];
          solMovement = up-colsol[j];
   assert(movement>0.99999)(static_cast<void> (0));
   if (fabs(up-colUpper[j])<1.0e-7) {
     goingToTrueBound=2;
     up=colUpper[j];
   }
 }
 if (goingToTrueBound&&(colUpper[j]-colLower[j]>1.5||colLower[j]))
   goingToTrueBound=1;
 // switch off disaggregation if not wanted
 if ((rowCuts&1)==0)
   goingToTrueBound=0;
6013#ifdef PRINT_DEBUG
 if (fabs(movement)>1.01) {
   printf("big %d %g %g %g\n",j,colLower[j],solval,colUpper[j]);
 }
6017#endif
 if (solMovement*djs[j]>0.0)
   objVal += solMovement*djs[j];
 nstackC=1;
 nstackR=0;
 saveL[0]=colLower[j];
 saveU[0]=colUpper[j];
        assert (saveU[0]>saveL[0])(static_cast<void> (0));
 notFeasible=0;
 if (movement<0.0) {
   colUpper[j] += movement;
   colUpper[j] = floor(colUpper[j]+0.5);
6029#ifdef PRINT_DEBUG
   printf("** Trying %d down to 0\n",j);
6031#endif
 } else {
   colLower[j] += movement;
   colLower[j] = floor(colLower[j]+0.5);
6035#ifdef PRINT_DEBUG
   printf("** Trying %d up to 1\n",j);
6037#endif
 }
 if (fabs(colUpper[j]-colLower[j])<1.0e-6) 
   markC[j]=3; // say fixed
 istackC=0;
 /* update immediately */
 for (k=columnStart[j];k<columnStart[j]+columnLength[j];k++) {
   int irow = row[k];
   value = columnElements[k];
   assert (markR[irow]!=-2)(static_cast<void> (0));
   if (markR[irow]==-1) {
     stackR[nstackR]=irow;
     markR[irow]=nstackR;
     saveMin[nstackR]=minR[irow];
     saveMax[nstackR]=maxR[irow];
     nstackR++;
6053#if 0
   } else if (markR[irow]==-2) {
     continue;
6056#endif
   }
   /* could check immediately if violation */
   if (movement>0.0) {
     /* up */
     if (value>0.0) {
/* up does not change - down does */
              if (minR[irow]>-1.0e10)
                minR[irow] += value;
if (minR[irow]>rowUpper[irow]+1.0e-5) {
  notFeasible=1;
  istackC=1;
  break;
}
     } else {
/* down does not change - up does */
              if (maxR[irow]<1.0e10)
                maxR[irow] += value;
if (maxR[irow]<rowLower[irow]-1.0e-5) {
  notFeasible=1;
  istackC=1;
  break;
}
     }
   } else {
     /* down */
     if (value<0.0) {
/* up does not change - down does */
              if (minR[irow]>-1.0e10)
                minR[irow] -= value;
if (minR[irow]>rowUpper[irow]+1.0e-5) {
  notFeasible=1;
  istackC=1;
  break;
}
     } else {
/* down does not change - up does */
              if (maxR[irow]<1.0e10)
                maxR[irow] -= value;
if (maxR[irow]<rowLower[irow]-1.0e-5) {
  notFeasible=1;
  istackC=1;
  break;
}
     }
   }
 }
 while (istackC<nstackC&&nstackC<maxStack) {
   int jway;
   int jcol =stackC[istackC];
   jway=markC[jcol];
   // If not first and fixed then skip
   if (jway==3&&istackC) {
     //istackC++;
     //continue;
            //printf("fixed %d on stack\n",jcol);
   }
   // Do cliques
   if (oneFixStart_&&oneFixStart_[jcol]>=0) {
     int start;
     int end;
     if (colLower[jcol]>saveL[istackC]) {
// going up
start = oneFixStart_[jcol];
end = zeroFixStart_[jcol];
     } else {
assert (colUpper[jcol]<saveU[istackC])(static_cast<void> (0));
// going down
start = zeroFixStart_[jcol];
end = endFixStart_[jcol];
     }
     for (int i=start;i<end;i++) {
int iClique = whichClique_[i];
for (int k=cliqueStart_[iClique];k<cliqueStart_[iClique+1];k++) {
  int kcol = sequenceInCliqueEntry(cliqueEntry_[k]);
                if (jcol==kcol)
                  continue;
  int kway = oneFixesInCliqueEntry(cliqueEntry_[k]);
                if (kcol!=jcol) {
                  if (!markC[kcol]) {
                    // not on list yet
                    if (nstackC<2*maxStack) {
                      markC[kcol] = 3; // say fixed
                      fixThis++;
                      stackC[nstackC]=kcol;
                      saveL[nstackC]=colLower[kcol];
                      saveU[nstackC]=colUpper[kcol];
                      assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                      nstackC++;
                      if (!kway) {
                        // going up
                        double solMovement=1.0-colsol[kcol];
                        if (solMovement>0.0001) {
                          assert (djs[kcol]>=0.0)(static_cast<void> (0));
                          objVal += djs[kcol]*solMovement;
                        }
                        colLower[kcol]=1.0;
                        /* update immediately */
                        for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                          krow = row[jj];
                          value = columnElements[jj];
	    assert (markR[krow]!=-2)(static_cast<void> (0));
                          if (markR[krow]==-1) {
                            stackR[nstackR]=krow;
                            markR[krow]=nstackR;
                            saveMin[nstackR]=minR[krow];
                            saveMax[nstackR]=maxR[krow];
                            nstackR++;
6164#if 0
                          } else if (markR[krow]==-2) {
                            continue;
6167#endif
                          }
                          /* could check immediately if violation */
                          /* up */
                          if (value>0.0) {
                            /* up does not change - down does */
                            if (minR[krow]>-1.0e10)
                              minR[krow] += value;
                            if (minR[krow]>rowUpper[krow]+1.0e-5) {
                              colUpper[kcol]=-1.0e50; /* force infeasible */
                              break;
                            }
                          } else {
                            /* down does not change - up does */
                            if (maxR[krow]<1.0e10)
                              maxR[krow] += value;
                            if (maxR[krow]<rowLower[krow]-1.0e-5) {
                              notFeasible=1;
                              break;
                            }
                          }
                        }
                      } else {
                        // going down
                        double solMovement=0.0-colsol[kcol];
                        if (solMovement<-0.0001) {
                          assert (djs[kcol]<=0.0)(static_cast<void> (0));
                          objVal += djs[kcol]*solMovement;
                        }
                        colUpper[kcol]=0.0;
                        /* update immediately */
                        for (int jj =columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                          krow = row[jj];
                          value = columnElements[jj];
	    assert (markR[krow]!=-2)(static_cast<void> (0));
                          if (markR[krow]==-1) {
                            stackR[nstackR]=krow;
                            markR[krow]=nstackR;
                            saveMin[nstackR]=minR[krow];
                            saveMax[nstackR]=maxR[krow];
                            nstackR++;
6208#if 0
                          } else if (markR[krow]==-2) {
                            continue;
6211#endif
                          }
                          /* could check immediately if violation */
                          /* down */
                          if (value<0.0) {
                            /* up does not change - down does */
                            if (minR[krow]>-1.0e10)
                              minR[krow] -= value;
                            if (minR[krow]>rowUpper[krow]+1.0e-5) {
                              notFeasible=1;
                              break;
                            }
                          } else {
                            /* down does not change - up does */
                            if (maxR[krow]<1.0e10)
                              maxR[krow] -= value;
                            if (maxR[krow]<rowLower[krow]-1.0e-5) {
                              notFeasible=1;
                              break;
                            }
                          }
                        }
                      }
                    }
                  } else if (markC[kcol]==1) {
                    // marked as going to 0
                    assert (!colUpper[kcol])(static_cast<void> (0));
                    if (!kway) {
                      // contradiction
                      notFeasible=1;
                      break;
                    }
                  } else if (markC[kcol]==2) {
                    // marked as going to 1
                    assert (colLower[kcol])(static_cast<void> (0));
                    if (kway) {
                      // contradiction
                      notFeasible=1;
                      break;
                    }
                  } else {
                    // marked as fixed
                    assert (markC[kcol]==3)(static_cast<void> (0));
                    int jkway;
                    if (colLower[kcol])
                      jkway=1;
                    else
                      jkway=0;
                    if (kway==jkway) {
                      // contradiction
                      notFeasible=1;
                      break;
                    }
                  }
                }
}
if (notFeasible)
  break;
     }
     if (notFeasible)
istackC=nstackC+1;
   }
   for (k=columnStart[jcol];k<columnStart[jcol]+columnLength[jcol];k++) {
     // break if found not feasible
     if (notFeasible)
break;
     int irow = row[k];
     /*value = columnElements[k];*/
     assert (markR[irow]!=-2)(static_cast<void> (0));
6280#if 0
     if (markR[irow]!=-2) {
6282#endif
/* see if anything forced */
for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];kk++) {
  double moveUp=0.0;
  double moveDown=0.0;
  double newUpper=-1.0,newLower=1.0;
  kcol=column[kk];
  bool onList = (markC[kcol]!=0);
  if (markC[kcol]!=3) {
    value2=rowElements[kk];
                  int markIt=markC[kcol];
    if (value2 < 0.0) {
      if (colUpper[kcol] < 1e10 && (markIt&2)==0 &&
	  rowUpper[irow]<1.0e10) {
	dbound = colUpper[kcol]+
	  (rowUpper[irow]-minR[irow])/value2;
	if (dbound > colLower[kcol] + primalTolerance_) {
	  if (intVar[kcol]) {
                          markIt |= 2;
	    newLower = ceil(dbound-primalTolerance_);
	  } else {
	    newLower=dbound;
	    if (newLower+primalTolerance_>colUpper[kcol]&&
		newLower-primalTolerance_<=colUpper[kcol]) {
	      newLower=colUpper[kcol];
                            markIt |= 2;
                            //markIt=3;
	    } else {
                            // avoid problems - fix later ?
                            markIt=3;
                          }
	  }
	  moveUp = newLower-colLower[kcol];
	}
      }
      if (colLower[kcol] > -1e10 && (markIt&1)==0 &&
	  rowLower[irow]>-1.0e10) {
	dbound = colLower[kcol] + 
	  (rowLower[irow]-maxR[irow])/value2;
	if (dbound < colUpper[kcol] - primalTolerance_) {
	  if (intVar[kcol]) {
	    markIt |= 1;
	    newUpper = floor(dbound+primalTolerance_);
	  } else {
	    newUpper=dbound;
	    if (newUpper-primalTolerance_<colLower[kcol]&&
		newUpper+primalTolerance_>=colLower[kcol]) {
	      newUpper=colLower[kcol];
                            markIt |= 1;
                            //markIt=3;
	    } else {
                            // avoid problems - fix later ?
                            markIt=3;
                          }
	  }
	  moveDown = newUpper-colUpper[kcol];
	}
      }
    } else {
      /* positive element */
      if (colUpper[kcol] < 1e10 && (markIt&2)==0 &&
	  rowLower[irow]>-1.0e10) {
	dbound = colUpper[kcol] + 
	  (rowLower[irow]-maxR[irow])/value2;
	if (dbound > colLower[kcol] + primalTolerance_) {
	  if (intVar[kcol]) {
	    markIt |= 2;
	    newLower = ceil(dbound-primalTolerance_);
	  } else {
	    newLower=dbound;
	    if (newLower+primalTolerance_>colUpper[kcol]&&
		newLower-primalTolerance_<=colUpper[kcol]) {
	      newLower=colUpper[kcol];
                            markIt |= 2;
                            //markIt=3;
	    } else {
                            // avoid problems - fix later ?
                            markIt=3;
	    }
	  }
	  moveUp = newLower-colLower[kcol];
	}
      }
      if (colLower[kcol] > -1e10 && (markIt&1)==0 &&
	  rowUpper[irow]<1.0e10) {
	dbound = colLower[kcol] + 
	  (rowUpper[irow]-minR[irow])/value2;
	if (dbound < colUpper[kcol] - primalTolerance_) {
	  if (intVar[kcol]) {
	    markIt |= 1;
	    newUpper = floor(dbound+primalTolerance_);
	  } else {
	    newUpper=dbound;
	    if (newUpper-primalTolerance_<colLower[kcol]&&
		newUpper+primalTolerance_>=colLower[kcol]) {
	      newUpper=colLower[kcol];
                            markIt |= 1;
                            //markIt=3;
	    } else {
                            // avoid problems - fix later ?
                            markIt=3;
	    }
	  }
	  moveDown = newUpper-colUpper[kcol];
	}
      }
    }
    if (nstackC<2*maxStack) {
                    markC[kcol] = markIt;
    }
    if (moveUp&&nstackC<2*maxStack) {
      fixThis++;
6394#ifdef PRINT_DEBUG
      printf("lower bound on %d increased from %g to %g by row %d %g %g\n",kcol,colLower[kcol],newLower,irow,rowLower[irow],rowUpper[irow]);
      value=0.0;
      for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
	int ii=column[jj];
	if (colUpper[ii]-colLower[ii]>primalTolerance_) {
	  printf("(%d, %g) ",ii,rowElements[jj]);
	} else {
	  value += rowElements[jj]*colLower[ii];
	}
      }
      printf(" - fixed %g\n",value);
      for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
	int ii=column[jj];
	if (colUpper[ii]-colLower[ii]<primalTolerance_) {
	  printf("(%d, %g, %g) ",ii,rowElements[jj],colLower[ii]);
	}
      }
      printf("\n");
6413#endif
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
                      assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newLower>colsol[kcol]) {
	if (djs[kcol]<0.0) {
	  /* should be infeasible */
	  assert (newLower>colUpper[kcol]+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveUp*djs[kcol];
	}
      }
      if (intVar[kcol])
	newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
      colLower[kcol]=newLower;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      /* update immediately */
      for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	krow = row[jj];
	value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
6447#if 0
	} else if (markR[krow]==-2) {
	  continue;
6450#endif
	}
	/* could check immediately if violation */
	/* up */
	if (value>0.0) {
	  /* up does not change - down does */
                        if (minR[krow]>-1.0e10)
                          minR[krow] += value*moveUp;
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	} else {
	  /* down does not change - up does */
                        if (maxR[krow]<1.0e10)
                          maxR[krow] += value*moveUp;
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	}
      }
    }
    if (moveDown&&nstackC<2*maxStack) {
      fixThis++;
6475#ifdef PRINT_DEBUG
      printf("upper bound on %d decreased from %g to %g by row %d %g %g\n",kcol,colUpper[kcol],newUpper,irow,rowLower[irow],rowUpper[irow]);
      value=0.0;
      for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
	int ii=column[jj];
	if (colUpper[ii]-colLower[ii]>primalTolerance_) {
	  printf("(%d, %g) ",ii,rowElements[jj]);
	} else {
	  value += rowElements[jj]*colLower[ii];
	}
      }
      printf(" - fixed %g\n",value);
      for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
	int ii=column[jj];
	if (colUpper[ii]-colLower[ii]<primalTolerance_) {
	  printf("(%d, %g, %g) ",ii,rowElements[jj],colLower[ii]);
	}
      }
      printf("\n");
6494#endif
      if (!onList) {
	stackC[nstackC]=kcol;
	saveL[nstackC]=colLower[kcol];
	saveU[nstackC]=colUpper[kcol];
                      assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
	nstackC++;
	onList=true;
      }
      if (newUpper<colsol[kcol]) {
	if (djs[kcol]>0.0) {
	  /* should be infeasible */
	  assert (colLower[kcol]>newUpper+primalTolerance_)(static_cast<void> (0));
	} else {
	  objVal += moveDown*djs[kcol];
	}
      }
      if (intVar[kcol])
	newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
      colUpper[kcol]=newUpper;
      if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
	markC[kcol]=3; // say fixed
      }
      /* update immediately */
      for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
	krow = row[jj];
	value = columnElements[jj];
	assert (markR[krow]!=-2)(static_cast<void> (0));
	if (markR[krow]==-1) {
	  stackR[nstackR]=krow;
	  markR[krow]=nstackR;
	  saveMin[nstackR]=minR[krow];
	  saveMax[nstackR]=maxR[krow];
	  nstackR++;
6528#if 0
	} else if (markR[krow]==-2) {
6530#endif
	  continue;
	}
	/* could check immediately if violation */
	/* down */
	if (value<0.0) {
	  /* up does not change - down does */
                        if (minR[krow]>-1.0e10)
                          minR[krow] += value*moveDown;
	  if (minR[krow]>rowUpper[krow]+1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	} else {
	  /* down does not change - up does */
                        if (maxR[krow]<1.0e10)
                          maxR[krow] += value*moveDown;
	  if (maxR[krow]<rowLower[krow]-1.0e-5) {
	    colUpper[kcol]=-1.0e50; /* force infeasible */
	    break;
	  }
	}
      }
    }
    if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
      notFeasible=1;;
      k=columnStart[jcol]+columnLength[jcol];
      istackC=nstackC+1;
6558#ifdef PRINT_DEBUG
      printf("** not feasible this way\n");
6560#endif
      break;
    }
  }
}
6565#if 0
     }
6567#endif
   }
   istackC++;
 }
 if (!notFeasible) {
   if (objVal<=cutoff) {
     feasible |= feas[iway];
   } else {
6575#ifdef PRINT_DEBUG
     printf("not feasible on dj\n");
6577#endif
     notFeasible=1;
     if (iway==1&&feasible==0) {
/* not feasible at all */
ninfeas=1;
j=nCols-1;
break;
     }
   }
 } else if (iway==1&&feasible==0) {
   /* not feasible at all */
   ninfeas=1;
   j=nCols-1;
          iLook=numberThisTime_;
   ipass=maxPass;
   break;
 }
 if (notFeasible)
   goingToTrueBound=0;
 if (iway==2||(iway==1&&feasible==2)) {
   /* keep */
   iway=3;
   nfixed++;
          if (mode_) {
     OsiColCut cc;
     int nTot=0,nFix=0,nInt=0;
     bool ifCut=false;
     for (istackC=0;istackC<nstackC;istackC++) {
int icol=stackC[istackC];
if (intVar[icol]) {
  if (colUpper[icol]<currentColUpper[icol]-1.0e-4) {
    element[nFix]=colUpper[icol];
    index[nFix++]=icol;
    nInt++;
    if (colsol[icol]>colUpper[icol]+primalTolerance_) {
      ifCut=true;
      anyColumnCuts=true;
    }
  }
}
     }
     if (nFix) {
nTot=nFix;
cc.setUbs(nFix,index,element);
nFix=0;
     }
     for (istackC=0;istackC<nstackC;istackC++) {
int icol=stackC[istackC];
if (intVar[icol]) {
  if (colLower[icol]>currentColLower[icol]+1.0e-4) {
    element[nFix]=colLower[icol];
    index[nFix++]=icol;
    nInt++;
    if (colsol[icol]<colLower[icol]-primalTolerance_) {
      ifCut=true;
      anyColumnCuts=true;
    }
  }
}
     }
     if (nFix) {
nTot+=nFix;
cc.setLbs(nFix,index,element);
     }
     // could tighten continuous as well
     if (nInt) {
if (ifCut) {
  cc.setEffectiveness(100.0);
} else {
  cc.setEffectiveness(1.0e-5);
}
6648#ifdef CGL_DEBUG
checkBounds(debugger,cc);
6650#endif
cs.insert(cc);
     }
   }
   for (istackC=0;istackC<nstackC;istackC++) {
     int icol=stackC[istackC];
     if (colUpper[icol]-colLower[icol]>primalTolerance_) {
markC[icol]=0;
     } else {
markC[icol]=3;
     }
   }
   for (istackR=0;istackR<nstackR;istackR++) {
     int irow=stackR[istackR];
     markR[irow]=-1;
   }
 } else {
   /* is it worth seeing if can increase coefficients
      or maybe better see if it is a cut */
   if (iway==0) {
     nstackC0=CoinMin(nstackC,maxStack);
     double solMove = saveSolval-down;
     double boundChange;
     if (notFeasible) {
nstackC0=0;
     } else {
for (istackC=0;istackC<nstackC0;istackC++) {
  int icol=stackC[istackC];
  stackC0[istackC]=icol;
  lo0[istackC]=colLower[icol];
  up0[istackC]=colUpper[icol];
}
     }
     /* restore all */
            int nCliquesAffected=0;
            assert (iway==0)(static_cast<void> (0));
     for (istackC=nstackC-1;istackC>=0;istackC--) {
int icol=stackC[istackC];
double oldU=saveU[istackC];
double oldL=saveL[istackC];
if(goingToTrueBound==2&&istackC) {
                // Work for extending cliques
                if (!mode_&&numberCliques_) {
                  int i_01 = to_01[icol];
                  if (i_01>=0) {
                    int start;
                    int end;
                    if (colLower[icol]) {
                      // going up - but we want weak way
                      start = zeroFixStart_[icol];
                      end = endFixStart_[icol];
                    } else {
                      // going down - but we want weak way
                      start = oneFixStart_[icol];
                      end = zeroFixStart_[icol];
                    }
                    //if (end>start)
                    //printf("j %d, other %d is in %d cliques\n",
                    //     j,i_01,end-start);
                    for (int i=start;i<end;i++) {
                      int iClique = whichClique_[i];
                      int size = cliqueStart_[iClique+1]-cliqueStart_[iClique];
                      if (cliqueCount[iClique]==size) {
                        // first time
                        cliqueStack[nCliquesAffected++]=iClique;
                      }
                      // decrement counts
                      cliqueCount[iClique]--;
                    }
                  }
                }
  // upper disaggregation cut would be
  // xval < upper + (old_upper-upper) (jval-down)
  boundChange = oldU-colUpper[icol];
  if (boundChange>0.0&&oldU<1.0e10&&
      (!mode_||colsol[icol]>colUpper[icol]
      + boundChange*solMove+primalTolerance_)) {
    // create cut
    OsiRowCut rc;
    rc.setLb(-COIN_DBL_MAX);
    rc.setUb(colUpper[icol]-down*boundChange);
    index[0]=icol;
    element[0]=1.0;
    index[1]=j;
    element[1]= - boundChange;
    // effectiveness is how far j moves
    double newSol = (colsol[icol]-colUpper[icol])/
      boundChange;
    if (mode_) 
      assert(newSol>solMove)(static_cast<void> (0));
    rc.setEffectiveness(newSol-solMove);
    if (rc.effectiveness()>disaggEffectiveness) {
      rc.setRow(2,index,element,false);
6743#ifdef CGL_DEBUG
      if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
6745#endif
      rowCut.addCutIfNotDuplicate(rc);
    }
  }
  // lower disaggregation cut would be
  // xval > lower + (old_lower-lower) (jval-down)
  boundChange = oldL-colLower[icol];
  if (boundChange<0.0&&oldL>-1.0e10&&
      (!mode_||colsol[icol]<colLower[icol]
      + boundChange*solMove-primalTolerance_)) {
    // create cut
    OsiRowCut rc;
    rc.setLb(colLower[icol]-down*boundChange);
    rc.setUb(COIN_DBL_MAX);
    index[0]=icol;
    element[0]=1.0;
    index[1]=j;
    element[1]=- boundChange;
    // effectiveness is how far j moves
    double newSol = (colsol[icol]-colLower[icol])/
      boundChange;
    if (mode_)
      assert(newSol>solMove)(static_cast<void> (0));
    rc.setEffectiveness(newSol-solMove);
    if (rc.effectiveness()>disaggEffectiveness) {
      rc.setRow(2,index,element,false);
6771#ifdef CGL_DEBUG
      if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
6773#endif
      rowCut.addCutIfNotDuplicate(rc);
6775#if 0
      printf("%d original bounds %g, %g new Lo %g sol= %g int %d sol= %g\n",icol,oldL,oldU,colLower[icol],colsol[icol], j, colsol[j]);
      printf("-1.0 * x(%d) + %g * y(%d) <= %g\n",
	     icol,boundChange,j,rc.ub());
6779#endif
    }
  }
}
colUpper[icol]=oldU;
colLower[icol]=oldL;
markC[icol]=0;
     }
            if (nCliquesAffected) {
              for (int i=0;i<nCliquesAffected;i++) {
                int iClique = cliqueStack[i];
                int size = cliqueCount[iClique];
                // restore
                cliqueCount[iClique]= cliqueStart_[iClique+1]-cliqueStart_[iClique];
                if (!size) {
                  if (logLevel_>1)
                    printf("** could extend clique by adding j!\n");
                }
              }
            }
     for (istackR=0;istackR<nstackR;istackR++) {
int irow=stackR[istackR];
// switch off strengthening if not wanted
if ((rowCuts&2)!=0&&goingToTrueBound) {
  bool ifCut=anyColumnCuts;
  double gap = rowUpper[irow]-maxR[irow];
  double sum=0.0;
  if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
    // see if the strengthened row is a cut
    for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	 kk++) {
      sum += rowElements[kk]*colsol[column[kk]];
    }
    if (sum-gap*colsol[j]>maxR[irow]+primalTolerance_||(info->strengthenRow&&rowLower[irow]<-1.0e20)) {
      // can be a cut
      // subtract gap from upper and integer coefficient
      // saveU and saveL spare
      int * index = reinterpret_cast<int *>(saveL);
      double * element = saveU;
      int n=0;
                    bool coefficientExists=false;
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	if (column[kk]!=j) {
	  index[n]=column[kk];
	  element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]-gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=-gap;
      }
      OsiRowCut rc;
      rc.setLb(-COIN_DBL_MAX);
      rc.setUb(rowUpper[irow]-gap*(colLower[j]+1.0));
      // effectiveness is how far j moves
      rc.setEffectiveness((sum-gap*colsol[j]-maxR[irow])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
6845#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
6847#endif
                      // If strengthenRow point to row
                      //if(info->strengthenRow)
                      //printf("a point to row %d\n",irow);
6851#ifdef STRENGTHEN_PRINT
      if (rowLower[irow]<-1.0e20) {
	printf("5Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
6875#endif
      int realRow = (rowLower[irow]<-1.0e20) ? irow : -1;
      if (realRows&&realRow>0)
	realRow=realRows[realRow];
      rowCut.addCutIfNotDuplicate(rc,realRow);
      }
    }
  }
  gap = minR[irow]-rowLower[irow];
  if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
    // see if the strengthened row is a cut
    if (!sum) {
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	sum += rowElements[kk]*colsol[column[kk]];
      }
    }
    if (sum+gap*colsol[j]<minR[irow]+primalTolerance_||(info->strengthenRow&&rowUpper[irow]>1.0e20)) {
      // can be a cut
      // add gap to lower and integer coefficient
      // saveU and saveL spare
      int * index = reinterpret_cast<int *>(saveL);
      double * element = saveU;
      int n=0;
                    bool coefficientExists=false;
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	if (column[kk]!=j) {
	  index[n]=column[kk];
	  element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]+gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=gap;
      }
      OsiRowCut rc;
      rc.setLb(rowLower[irow]+gap*(colLower[j]+1.0));
      rc.setUb(COIN_DBL_MAX);
      // effectiveness is how far j moves
      rc.setEffectiveness((minR[irow]-sum-gap*colsol[j])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
6925#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
6927#endif
                      //if(info->strengthenRow)
                      //printf("b point to row %d\n",irow);
6930#ifdef STRENGTHEN_PRINT
      if (rowUpper[irow]>1.0e20) {
	printf("6Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
6954#endif
      int realRow = (rowUpper[irow]>1.0e20) ? irow : -1;
      if (realRows&&realRow>0)
	realRow=realRows[realRow];
      rowCut.addCutIfNotDuplicate(rc,realRow);
      }
    }
  }
}
minR[irow]=saveMin[istackR];
maxR[irow]=saveMax[istackR];
markR[irow]=-1;
     }
   } else {
     if (iway==1&&feasible==3) {
iway=3;
/* point back to stack */
for (istackC=nstackC-1;istackC>=0;istackC--) {
  int icol=stackC[istackC];
  markC[icol]=istackC+1000;
}
if (mode_) {
  OsiColCut cc;
  int nTot=0,nFix=0,nInt=0;
  bool ifCut=false;
  for (istackC=0;istackC<nstackC0;istackC++) {
    int icol=stackC0[istackC];
    int istackC1=markC[icol]-1000;
    if (istackC1>=0) {
      if (CoinMin(lo0[istackC],colLower[icol])>saveL[istackC1]+1.0e-4) {
	saveL[istackC1]=CoinMin(lo0[istackC],colLower[icol]);
	if (intVar[icol]) {
	  element[nFix]=saveL[istackC1];
	  index[nFix++]=icol;
	  nInt++;
	  if (colsol[icol]<saveL[istackC1]-primalTolerance_)
	    ifCut=true;
	}
	nfixed++;
      }
    }
  }
  if (nFix) {
    nTot=nFix;
    cc.setLbs(nFix,index,element);
    nFix=0;
  }
  for (istackC=0;istackC<nstackC0;istackC++) {
    int icol=stackC0[istackC];
    int istackC1=markC[icol]-1000;
    if (istackC1>=0) {
      if (CoinMax(up0[istackC],colUpper[icol])<saveU[istackC1]-1.0e-4) {
	saveU[istackC1]=CoinMax(up0[istackC],colUpper[icol]);
	if (intVar[icol]) {
	  element[nFix]=saveU[istackC1];
	  index[nFix++]=icol;
	  nInt++;
	  if (colsol[icol]>saveU[istackC1]+primalTolerance_)
	    ifCut=true;
	}
	nfixed++;
      }
    }
  }
  if (nFix) {
    nTot+=nFix;
    cc.setUbs(nFix,index,element);
  }
  // could tighten continuous as well
  if (nInt) {
    if (ifCut) {
      cc.setEffectiveness(100.0);
    } else {
      cc.setEffectiveness(1.0e-5);
    }
7029#ifdef CGL_DEBUG
    checkBounds(debugger,cc);
7031#endif
    cs.insert(cc);
  }
}
     } else {
goingToTrueBound=0;
     }
     double solMove = up-saveSolval;
     double boundChange;
     /* restore all */
            int nCliquesAffected=0;
     for (istackC=nstackC-1;istackC>=0;istackC--) {
int icol=stackC[istackC];
double oldU=saveU[istackC];
double oldL=saveL[istackC];
if(goingToTrueBound==2&&istackC) {
                // Work for extending cliques
                if (!mode_&&numberCliques_&&iway==3) {
                  int i_01 = to_01[icol];
                  if (i_01>=0) {
                    int start;
                    int end;
                    if (colLower[icol]) {
                      // going up - but we want weak way
                      start = zeroFixStart_[icol];
                      end = endFixStart_[icol];
                    } else {
                      // going down - but we want weak way
                      start = oneFixStart_[icol];
                      end = zeroFixStart_[icol];
                    }
                    //if (end>start)
                    //printf("up j %d, other %d is in %d cliques\n",
                    //     j,i_01,end-start);
                    for (int i=start;i<end;i++) {
                      int iClique = whichClique_[i];
                      int size = cliqueStart_[iClique+1]-cliqueStart_[iClique];
                      if (cliqueCount[iClique]==size) {
                        // first time
                        cliqueStack[nCliquesAffected++]=iClique;
                      }
                      // decrement counts
                      cliqueCount[iClique]--;
                    }
                  }
                }
  // upper disaggregation cut would be
  // xval < upper + (old_upper-upper) (up-jval)
  boundChange = oldU-colUpper[icol];
  if (boundChange>0.0&&oldU<1.0e10&&
      (!mode_||colsol[icol]>colUpper[icol]
      + boundChange*solMove+primalTolerance_)) {
    // create cut
    OsiRowCut rc;
    rc.setLb(-COIN_DBL_MAX);
    rc.setUb(colUpper[icol]+up*boundChange);
    index[0]=icol;
    element[0]=1.0;
    index[1]=j;
    element[1]= + boundChange;
    // effectiveness is how far j moves
    double newSol = (colsol[icol]-colUpper[icol])/
      boundChange;
    if (mode_)
      assert(newSol>solMove)(static_cast<void> (0));
    rc.setEffectiveness(newSol-solMove);
    if (rc.effectiveness()>disaggEffectiveness) {
      rc.setRow(2,index,element,false);
7099#ifdef CGL_DEBUG
      if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
7101#endif
      rowCut.addCutIfNotDuplicate(rc);
    }
  }
  // lower disaggregation cut would be
  // xval > lower + (old_lower-lower) (up-jval)
  boundChange = oldL-colLower[icol];
  if (boundChange<0.0&&oldL>-1.0e10&&
      (!mode_||colsol[icol]<colLower[icol]
      + boundChange*solMove-primalTolerance_)) {
    // create cut
    OsiRowCut rc;
    rc.setLb(colLower[icol]+up*boundChange);
    rc.setUb(COIN_DBL_MAX);
    index[0]=icol;
    element[0]=1.0;
    index[1]=j;
    element[1]= + boundChange;
    // effectiveness is how far j moves
    double newSol = (colsol[icol]-colLower[icol])/
      boundChange;
    if (mode_)
      assert(newSol>solMove)(static_cast<void> (0));
    rc.setEffectiveness(newSol-solMove);
    if (rc.effectiveness()>disaggEffectiveness) {
      rc.setRow(2,index,element,false);
7127#ifdef CGL_DEBUG
      if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
7129#endif
      rowCut.addCutIfNotDuplicate(rc);
    }
  }
}
colUpper[icol]=oldU;
colLower[icol]=oldL;
              if (oldU>oldL+1.0e-4)
                markC[icol]=0;
              else
                markC[icol]=3;
     }
            if (nCliquesAffected) {
              for (int i=0;i<nCliquesAffected;i++) {
                int iClique = cliqueStack[i];
                int size = cliqueCount[iClique];
                // restore
                cliqueCount[iClique]= cliqueStart_[iClique+1]-cliqueStart_[iClique];
                if (!size) {
                  if (logLevel_>1)
                    printf("** could extend clique by adding j!\n");
                }
              }
            }
     for (istackR=0;istackR<nstackR;istackR++) {
int irow=stackR[istackR];
// switch off strengthening if not wanted
if ((rowCuts&2)!=0&&goingToTrueBound) {
  bool ifCut=anyColumnCuts;
  double gap = rowUpper[irow]-maxR[irow];
  double sum=0.0;
  if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
    // see if the strengthened row is a cut
    for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	 kk++) {
      sum += rowElements[kk]*colsol[column[kk]];
    }
    if (sum+gap*colsol[j]>rowUpper[irow]+primalTolerance_||(info->strengthenRow&&rowLower[irow]<-1.0e20)) {
      // can be a cut
      // add gap to integer coefficient
      // saveU and saveL spare
      int * index = reinterpret_cast<int *>(saveL);
      double * element = saveU;
      int n=0;
                    bool coefficientExists=false;
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	if (column[kk]!=j) {
	  index[n]=column[kk];
	  element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]+gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=gap;
      }
      OsiRowCut rc;
      rc.setLb(-COIN_DBL_MAX);
      rc.setUb(rowUpper[irow]+gap*(colUpper[j]-1.0));
      // effectiveness is how far j moves
      rc.setEffectiveness((sum+gap*colsol[j]-rowUpper[irow])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
7199#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
7201#endif
                      //if(info->strengthenRow)
                      //printf("c point to row %d\n",irow);
7204#ifdef STRENGTHEN_PRINT
      if (rowLower[irow]<-1.0e20) {
	printf("7Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
7228#endif
      int realRow = (rowLower[irow]<-1.0e20) ? irow : -1;
      if (realRows&&realRow>0)
	realRow=realRows[realRow];
	rowCut.addCutIfNotDuplicate(rc,realRow);
      }
    }
  }
  gap = minR[irow]-rowLower[irow];
  if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
    // see if the strengthened row is a cut
    if (!sum) {
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	sum += rowElements[kk]*colsol[column[kk]];
      }
    }
    if (sum-gap*colsol[j]<rowLower[irow]+primalTolerance_||(info->strengthenRow&&rowUpper[irow]>1.0e20)) {
      // can be a cut
      // subtract gap from integer coefficient
      // saveU and saveL spare
      int * index = reinterpret_cast<int *>(saveL);
      double * element = saveU;
      int n=0;
                    bool coefficientExists=false;
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	if (column[kk]!=j) {
	  index[n]=column[kk];
	  element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]-gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=-gap;
      }
      OsiRowCut rc;
      rc.setLb(rowLower[irow]-gap*(colUpper[j]-1));
      rc.setUb(COIN_DBL_MAX);
      // effectiveness is how far j moves
      rc.setEffectiveness((rowLower[irow]-sum+gap*colsol[j])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
7278#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
7280#endif
                      //if(info->strengthenRow)
                      //printf("d point to row %d\n",irow);
7283#ifdef STRENGTHEN_PRINT
      if (rowUpper[irow]>1.0e20) {
	printf("8Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
7307#endif
      int realRow = (rowUpper[irow]>1.0e20) ? irow : -1;
      if (realRows&&realRow>0)
	realRow=realRows[realRow];
	rowCut.addCutIfNotDuplicate(rc,realRow);
      }
    }
  }
}
minR[irow]=saveMin[istackR];
maxR[irow]=saveMax[istackR];
markR[irow]=-1;
     }
   }
 }
}
    }
  }
}
delete [] cliqueStack;
delete [] cliqueCount;
delete [] to_01;
delete [] stackC0;
delete [] lo0;
delete [] up0;
delete [] tempL;
delete [] tempU;
delete [] markC;
delete [] stackC;
delete [] stackR;
delete [] saveL;
delete [] saveU;
delete [] saveMin;
delete [] saveMax;
delete [] index;
delete [] element;
delete [] djs;
delete [] colsol;
// Add in row cuts
if (!ninfeas) {
  rowCut.addCuts(cs,info->strengthenRow,0);
}
return (ninfeas);
7350}
7351// Does probing and adding cuts for clique slacks
7352int 
7353CglProbing::probeSlacks( const OsiSolverInterface & si, 
                        const OsiRowCutDebugger * 
7355#ifdef CGL_DEBUG
	 debugger
7357#endif
	 ,OsiCuts & cs, 
                        double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
	 CoinPackedMatrix *columnCopy,
                        double * rowLower, double * rowUpper,
                        char * intVar, double * minR, double * maxR,int * markR,
                        CglTreeInfo * info)
7364{
if (!numberCliques_)
  return 0;
// Set up maxes
int maxProbe = info->inTree ? maxProbe_ : maxProbeRoot_;
int maxStack = info->inTree ? maxStack_ : maxStackRoot_;
int nRows=rowCopy->getNumRows();
int nCols=rowCopy->getNumCols();
double * colsol = new double[nCols];
CoinMemcpyN( si.getColSolution(),nCols,colsol);
int rowCuts=rowCuts_;
double_int_pair * array = new double_int_pair [numberCliques_];
// look at <= cliques
int iClique;
int nLook=0;
for (iClique=0;iClique<numberCliques_;iClique++) {
  if (!cliqueType_[iClique].equality) {
    double sum=0.0;
    for (int j=cliqueStart_[iClique];j<cliqueStart_[iClique+1];j++) {
      int iColumn = sequenceInCliqueEntry(cliqueEntry_[j]);
      double value = colsol[iColumn];
      if (oneFixesInCliqueEntry(cliqueEntry_[j]))
        sum += value;
      else
        sum -= value;
    }
    double away = fabs(0.5-(sum-floor(sum)));
    if (away<0.49999) {
      array[nLook].infeasibility=away;
      array[nLook++].sequence=iClique;
    }
  }
}
std::sort(array,array+nLook,double_int_pair_compare());
nLook=CoinMin(nLook,maxProbe);
const double * currentColLower = si.getColLower();
const double * currentColUpper = si.getColUpper();
double * tempL = new double [nCols];
double * tempU = new double [nCols];
int * markC = new int [nCols];
int * stackC = new int [2*nCols];
int * stackR = new int [nRows];
double * saveL = new double [2*nCols];
double * saveU = new double [2*nCols];
double * saveMin = new double [nRows];
double * saveMax = new double [nRows];
double * element = new double[nCols];
int * index = new int[nCols];
// Let us never add more than twice the number of rows worth of row cuts
// Keep cuts out of cs until end so we can find duplicates quickly
int nRowsFake = info->inTree ? nRows/3 : nRows;
row_cut rowCut(nRowsFake, !info->inTree);
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths(); 
const double * rowElements = rowCopy->getElements();
const int * row = columnCopy->getIndices();
const CoinBigIndex * columnStart = columnCopy->getVectorStarts();
const int * columnLength = columnCopy->getVectorLengths(); 
const double * columnElements = columnCopy->getElements();
double movement;
int i, j, k,kk,jj;
int kcol,irow,krow;
bool anyColumnCuts=false;
double dbound, value, value2;
int ninfeas=0;
for (i = 0; i < nCols; ++i) {
  if (colUpper[i]-colLower[i]>1.0e-8) {
    if (colsol[i]<colLower[i]+primalTolerance_) {
      colsol[i]=colLower[i];
    } else if (colsol[i]>colUpper[i]-primalTolerance_) {
      colsol[i]=colUpper[i];
    }
  }
}

int ipass=0,nfixed=-1;

/* for both way coding */
int nstackC0=-1;
int * stackC0 = new int[maxStack];
double * lo0 = new double[maxStack];
double * up0 = new double[maxStack];
int nstackR,nstackC;
for (i=0;i<nCols;i++) {
  if (colUpper[i]-colLower[i]<1.0e-8) {
    markC[i]=3;
  } else {
    markC[i]=0;
  }
}
double tolerance = 1.0e1*primalTolerance_;
// If we are going to replace coefficient then we don't need to be effective
int maxPass = info->inTree ? maxPass_ : maxPassRoot_;
double needEffectiveness = info->strengthenRow ? -1.0e10 : 1.0e-3;
while (ipass<maxPass&&nfixed) {
  int iLook;
  ipass++;
  nfixed=0;
  for (iLook=0;iLook<nLook;iLook++) {
    double solval;
    double down;
    double up;
    int iClique=array[iLook].sequence;
    solval=0.0;
    j=0;
    for (j=cliqueStart_[iClique];j<cliqueStart_[iClique+1];j++) {
      int iColumn = sequenceInCliqueEntry(cliqueEntry_[j]);
      double value = colsol[iColumn];
      if (oneFixesInCliqueEntry(cliqueEntry_[j]))
        solval += value;
      else
        solval -= value;
    }
    down = floor(solval+tolerance);
    up = ceil(solval-tolerance);
    int istackC,iway, istackR;
    int way[]={1,2,1};
    int feas[]={1,2,4};
    int feasible=0;
    int notFeasible;
    for (iway=0;iway<3;iway ++) {
      int fixThis=0;
      stackC[0]=j;
      markC[j]=way[iway];
      if (way[iway]==1) {
        movement=down-colUpper[j];
        assert(movement<-0.99999)(static_cast<void> (0));
        down=colLower[j];
      } else {
        movement=up-colLower[j];
        assert(movement>0.99999)(static_cast<void> (0));
        up=colUpper[j];
      }
      nstackC=1;
      nstackR=0;
      saveL[0]=colLower[j];
      saveU[0]=colUpper[j];
      assert (saveU[0]>saveL[0])(static_cast<void> (0));
      notFeasible=0;
      if (movement<0.0) {
        colUpper[j] += movement;
        colUpper[j] = floor(colUpper[j]+0.5);
7507#ifdef PRINT_DEBUG
        printf("** Trying %d down to 0\n",j);
7509#endif
      } else {
        colLower[j] += movement;
        colLower[j] = floor(colLower[j]+0.5);
7513#ifdef PRINT_DEBUG
        printf("** Trying %d up to 1\n",j);
7515#endif
      }
      if (fabs(colUpper[j]-colLower[j])<1.0e-6) 
        markC[j]=3; // say fixed
      istackC=0;
      /* update immediately */
      for (k=columnStart[j];k<columnStart[j]+columnLength[j];k++) {
        int irow = row[k];
        value = columnElements[k];
        if (markR[irow]==-1) {
          stackR[nstackR]=irow;
          markR[irow]=nstackR;
          saveMin[nstackR]=minR[irow];
          saveMax[nstackR]=maxR[irow];
          nstackR++;
        } else if (markR[irow]==-2) {
          continue;
        }
        /* could check immediately if violation */
        if (movement>0.0) {
          /* up */
          if (value>0.0) {
            /* up does not change - down does */
            if (minR[irow]>-1.0e10)
              minR[irow] += value;
            if (minR[irow]>rowUpper[irow]+1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          } else {
            /* down does not change - up does */
            if (maxR[irow]<1.0e10)
              maxR[irow] += value;
            if (maxR[irow]<rowLower[irow]-1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          }
        } else {
          /* down */
          if (value<0.0) {
            /* up does not change - down does */
            if (minR[irow]>-1.0e10)
              minR[irow] -= value;
            if (minR[irow]>rowUpper[irow]+1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          } else {
            /* down does not change - up does */
            if (maxR[irow]<1.0e10)
              maxR[irow] -= value;
            if (maxR[irow]<rowLower[irow]-1.0e-5) {
              notFeasible=1;
              istackC=1;
              break;
            }
          }
        }
      }
      while (istackC<nstackC&&nstackC<maxStack) {
        int jway;
        int jcol =stackC[istackC];
        jway=markC[jcol];
        // If not first and fixed then skip
        if (jway==3&&istackC) {
          //istackC++;
          //continue;
          //printf("fixed %d on stack\n",jcol);
        }
        // Do cliques
        if (oneFixStart_&&oneFixStart_[jcol]>=0) {
          int start;
          int end;
          if (colLower[jcol]>saveL[istackC]) {
            // going up
            start = oneFixStart_[jcol];
            end = zeroFixStart_[jcol];
          } else {
            assert (colUpper[jcol]<saveU[istackC])(static_cast<void> (0));
            // going down
            start = zeroFixStart_[jcol];
            end = endFixStart_[jcol];
          }
          for (int i=start;i<end;i++) {
            int iClique = whichClique_[i];
            for (int k=cliqueStart_[iClique];k<cliqueStart_[iClique+1];k++) {
              int kcol = sequenceInCliqueEntry(cliqueEntry_[k]);
              if (jcol==kcol)
                continue;
              int kway = oneFixesInCliqueEntry(cliqueEntry_[k]);
              if (kcol!=jcol) {
                if (!markC[kcol]) {
                  // not on list yet
                  if (nstackC<2*maxStack) {
                    markC[kcol] = 3; // say fixed
                    fixThis++;
                    stackC[nstackC]=kcol;
                    saveL[nstackC]=colLower[kcol];
                    saveU[nstackC]=colUpper[kcol];
                    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                    nstackC++;
                    if (!kway) {
                      // going up
                      colLower[kcol]=1.0;
                      /* update immediately */
                      for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                        krow = row[jj];
                        value = columnElements[jj];
                        if (markR[krow]==-1) {
                          stackR[nstackR]=krow;
                          markR[krow]=nstackR;
                          saveMin[nstackR]=minR[krow];
                          saveMax[nstackR]=maxR[krow];
                          nstackR++;
                        } else if (markR[krow]==-2) {
                          continue;
                        }
                        /* could check immediately if violation */
                        /* up */
                        if (value>0.0) {
                          /* up does not change - down does */
                          if (minR[krow]>-1.0e10)
                            minR[krow] += value;
                          if (minR[krow]>rowUpper[krow]+1.0e-5) {
                            colUpper[kcol]=-1.0e50; /* force infeasible */
                            break;
                          }
                        } else {
                          /* down does not change - up does */
                          if (maxR[krow]<1.0e10)
                            maxR[krow] += value;
                          if (maxR[krow]<rowLower[krow]-1.0e-5) {
                            notFeasible=1;
                            break;
                          }
                        }
                      }
                    } else {
                      // going down
                      colUpper[kcol]=0.0;
                      /* update immediately */
                      for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                        krow = row[jj];
                        value = columnElements[jj];
                        if (markR[krow]==-1) {
                          stackR[nstackR]=krow;
                          markR[krow]=nstackR;
                          saveMin[nstackR]=minR[krow];
                          saveMax[nstackR]=maxR[krow];
                          nstackR++;
                        } else if (markR[krow]==-2) {
                          continue;
                        }
                        /* could check immediately if violation */
                        /* down */
                        if (value<0.0) {
                          /* up does not change - down does */
                          if (minR[krow]>-1.0e10)
                            minR[krow] -= value;
                          if (minR[krow]>rowUpper[krow]+1.0e-5) {
                            notFeasible=1;
                            break;
                          }
                        } else {
                          /* down does not change - up does */
                          if (maxR[krow]<1.0e10)
                            maxR[krow] -= value;
                          if (maxR[krow]<rowLower[krow]-1.0e-5) {
                            notFeasible=1;
                            break;
                          }
                        }
                      }
                    }
                  }
                } else if (markC[kcol]==1) {
                  // marked as going to 0
                  assert (!colUpper[kcol])(static_cast<void> (0));
                  if (!kway) {
                    // contradiction
                    notFeasible=1;
                    break;
                  }
                } else if (markC[kcol]==2) {
                  // marked as going to 1
                  assert (colLower[kcol])(static_cast<void> (0));
                  if (kway) {
                    // contradiction
                    notFeasible=1;
                    break;
                  }
                } else {
                  // marked as fixed
                  assert (markC[kcol]==3)(static_cast<void> (0));
                  int jkway;
                  if (colLower[kcol])
                    jkway=1;
                  else
                    jkway=0;
                  if (kway==jkway) {
                    // contradiction
                    notFeasible=1;
                    break;
                  }
                }
              }
            }
            if (notFeasible)
              break;
          }
          if (notFeasible)
            istackC=nstackC+1;
        }
        for (k=columnStart[jcol];k<columnStart[jcol]+columnLength[jcol];k++) {
          // break if found not feasible
          if (notFeasible)
            break;
          irow = row[k];
          /*value = columnElements[k];*/
          if (markR[irow]!=-2) {
            /* see if anything forced */
            for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];kk++) {
              double moveUp=0.0;
              double moveDown=0.0;
              double newUpper=-1.0,newLower=1.0;
              kcol=column[kk];
              bool onList = (markC[kcol]!=0);
              if (markC[kcol]!=3) {
                value2=rowElements[kk];
                int markIt=markC[kcol];
                if (value2 < 0.0) {
                  if (colUpper[kcol] < 1e10 && (markIt&2)==0 &&
                      rowUpper[irow]<1.0e10) {
                    dbound = colUpper[kcol]+
                      (rowUpper[irow]-minR[irow])/value2;
                    if (dbound > colLower[kcol] + primalTolerance_) {
                      if (intVar[kcol]) {
                        markIt |= 2;
                        newLower = ceil(dbound-primalTolerance_);
                      } else {
                        newLower=dbound;
                        if (newLower+primalTolerance_>colUpper[kcol]&&
                            newLower-primalTolerance_<=colUpper[kcol]) {
                          newLower=colUpper[kcol];
                          markIt |= 2;
                          markIt=3;
                        } else {
                          // avoid problems - fix later ?
                          markIt=3;
                        }
                      }
                      moveUp = newLower-colLower[kcol];
                    }
                  }
                  if (colLower[kcol] > -1e10 && (markIt&1)==0 &&
                      rowLower[irow]>-1.0e10) {
                    dbound = colLower[kcol] + 
                      (rowLower[irow]-maxR[irow])/value2;
                    if (dbound < colUpper[kcol] - primalTolerance_) {
                      if (intVar[kcol]) {
                        markIt |= 1;
                        newUpper = floor(dbound+primalTolerance_);
                      } else {
                        newUpper=dbound;
                        if (newUpper-primalTolerance_<colLower[kcol]&&
                            newUpper+primalTolerance_>=colLower[kcol]) {
                          newUpper=colLower[kcol];
                          markIt |= 1;
                          markIt=3;
                        } else {
                          // avoid problems - fix later ?
                          markIt=3;
                        }
                      }
                      moveDown = newUpper-colUpper[kcol];
                    }
                  }
                } else {
                  /* positive element */
                  if (colUpper[kcol] < 1e10 && (markIt&2)==0 &&
                      rowLower[irow]>-1.0e10) {
                    dbound = colUpper[kcol] + 
                      (rowLower[irow]-maxR[irow])/value2;
                    if (dbound > colLower[kcol] + primalTolerance_) {
                      if (intVar[kcol]) {
                        markIt |= 2;
                        newLower = ceil(dbound-primalTolerance_);
                      } else {
                        newLower=dbound;
                        if (newLower+primalTolerance_>colUpper[kcol]&&
                            newLower-primalTolerance_<=colUpper[kcol]) {
                          newLower=colUpper[kcol];
                          markIt |= 2;
                          markIt=3;
                        } else {
                          // avoid problems - fix later ?
                          markIt=3;
                        }
                      }
                      moveUp = newLower-colLower[kcol];
                    }
                  }
                  if (colLower[kcol] > -1e10 && (markIt&1)==0 &&
                      rowUpper[irow]<1.0e10) {
                    dbound = colLower[kcol] + 
                      (rowUpper[irow]-minR[irow])/value2;
                    if (dbound < colUpper[kcol] - primalTolerance_) {
                      if (intVar[kcol]) {
                        markIt |= 1;
                        newUpper = floor(dbound+primalTolerance_);
                      } else {
                        newUpper=dbound;
                        if (newUpper-primalTolerance_<colLower[kcol]&&
                            newUpper+primalTolerance_>=colLower[kcol]) {
                          newUpper=colLower[kcol];
                          markIt |= 1;
                          markIt=3;
                        } else {
                          // avoid problems - fix later ?
                          markIt=3;
                        }
                      }
                      moveDown = newUpper-colUpper[kcol];
                    }
                  }
                }
                if (nstackC<2*maxStack) {
                  markC[kcol] = markIt;
  }
                if (moveUp&&nstackC<2*maxStack) {
                  fixThis++;
7850#ifdef PRINT_DEBUG
                  printf("lower bound on %d increased from %g to %g by row %d %g %g\n",kcol,colLower[kcol],newLower,irow,rowLower[irow],rowUpper[irow]);
                  value=0.0;
                  for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
                    int ii=column[jj];
                    if (colUpper[ii]-colLower[ii]>primalTolerance_) {
                      printf("(%d, %g) ",ii,rowElements[jj]);
                    } else {
                      value += rowElements[jj]*colLower[ii];
                    }
                  }
                  printf(" - fixed %g\n",value);
                  for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
                    int ii=column[jj];
                    if (colUpper[ii]-colLower[ii]<primalTolerance_) {
                      printf("(%d, %g, %g) ",ii,rowElements[jj],colLower[ii]);
                    }
                  }
                  printf("\n");
7869#endif
                  if (!onList) {
                    stackC[nstackC]=kcol;
                    saveL[nstackC]=colLower[kcol];
                    saveU[nstackC]=colUpper[kcol];
                    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                    nstackC++;
                    onList=true;
                  }
                  if (intVar[kcol])
                    newLower = CoinMax(colLower[kcol],ceil(newLower-1.0e-4));
                  colLower[kcol]=newLower;
                  if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
                    markC[kcol]=3; // say fixed
    }
                  /* update immediately */
                  for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                    krow = row[jj];
                    value = columnElements[jj];
                    if (markR[krow]==-1) {
                      stackR[nstackR]=krow;
                      markR[krow]=nstackR;
                      saveMin[nstackR]=minR[krow];
                      saveMax[nstackR]=maxR[krow];
                      nstackR++;
                    } else if (markR[krow]==-2) {
                      continue;
                    }
                    /* could check immediately if violation */
                    /* up */
                    if (value>0.0) {
                      /* up does not change - down does */
                      if (minR[krow]>-1.0e10)
                        minR[krow] += value*moveUp;
                      if (minR[krow]>rowUpper[krow]+1.0e-5) {
                        colUpper[kcol]=-1.0e50; /* force infeasible */
                        break;
                      }
                    } else {
                      /* down does not change - up does */
                      if (maxR[krow]<1.0e10)
                        maxR[krow] += value*moveUp;
                      if (maxR[krow]<rowLower[krow]-1.0e-5) {
                        colUpper[kcol]=-1.0e50; /* force infeasible */
                        break;
                      }
                    }
                  }
                }
                if (moveDown&&nstackC<2*maxStack) {
                  fixThis++;
7920#ifdef PRINT_DEBUG
                  printf("upper bound on %d decreased from %g to %g by row %d %g %g\n",kcol,colUpper[kcol],newUpper,irow,rowLower[irow],rowUpper[irow]);
                  value=0.0;
                  for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
                    int ii=column[jj];
                    if (colUpper[ii]-colLower[ii]>primalTolerance_) {
                      printf("(%d, %g) ",ii,rowElements[jj]);
                    } else {
                      value += rowElements[jj]*colLower[ii];
                    }
                  }
                  printf(" - fixed %g\n",value);
                  for (jj=rowStart[irow];jj<rowStart[irow]+rowLength[irow];jj++) {
                    int ii=column[jj];
                    if (colUpper[ii]-colLower[ii]<primalTolerance_) {
                      printf("(%d, %g, %g) ",ii,rowElements[jj],colLower[ii]);
                    }
                  }
                  printf("\n");
7939#endif
                  if (!onList) {
                    stackC[nstackC]=kcol;
                    saveL[nstackC]=colLower[kcol];
                    saveU[nstackC]=colUpper[kcol];
                    assert (saveU[nstackC]>saveL[nstackC])(static_cast<void> (0));
                    nstackC++;
                    onList=true;
                  }
                  if (intVar[kcol])
                    newUpper = CoinMin(colUpper[kcol],floor(newUpper+1.0e-4));
                  colUpper[kcol]=newUpper;
                  if (fabs(colUpper[kcol]-colLower[kcol])<1.0e-6) {
                    markC[kcol]=3; // say fixed
    }
                  /* update immediately */
                  for (jj=columnStart[kcol];jj<columnStart[kcol]+columnLength[kcol];jj++) {
                    krow = row[jj];
                    value = columnElements[jj];
                    if (markR[krow]==-1) {
                      stackR[nstackR]=krow;
                      markR[krow]=nstackR;
                      saveMin[nstackR]=minR[krow];
                      saveMax[nstackR]=maxR[krow];
                      nstackR++;
                    } else if (markR[krow]==-2) {
                      continue;
                    }
                    /* could check immediately if violation */
                    /* down */
                    if (value<0.0) {
                      /* up does not change - down does */
                      if (minR[krow]>-1.0e10)
                        minR[krow] += value*moveDown;
                      if (minR[krow]>rowUpper[krow]+1.0e-5) {
                        colUpper[kcol]=-1.0e50; /* force infeasible */
                        break;
                      }
                    } else {
                      /* down does not change - up does */
                      if (maxR[krow]<1.0e10)
                        maxR[krow] += value*moveDown;
                      if (maxR[krow]<rowLower[krow]-1.0e-5) {
                        colUpper[kcol]=-1.0e50; /* force infeasible */
                        break;
                      }
                    }
                  }
                }
                if (colLower[kcol]>colUpper[kcol]+primalTolerance_) {
                  notFeasible=1;;
                  k=columnStart[jcol]+columnLength[jcol];
                  istackC=nstackC+1;
7992#ifdef PRINT_DEBUG
                  printf("** not feasible this way\n");
7994#endif
                  break;
                }
              }
            }
          }
        }
        istackC++;
      }
      if (!notFeasible) {
        feasible |= feas[iway];
      } else if (iway==1&&feasible==0) {
        /* not feasible at all */
        ninfeas=1;
        j=nCols-1;
        iLook=nLook;
        ipass=maxPass;
        break;
      }
      if (iway==2||(iway==1&&feasible==2)) {
        /* keep */
        iway=3;
        nfixed++;
        if (mode_) {
          OsiColCut cc;
          int nTot=0,nFix=0,nInt=0;
          bool ifCut=false;
          for (istackC=0;istackC<nstackC;istackC++) {
            int icol=stackC[istackC];
            if (intVar[icol]) {
              if (colUpper[icol]<currentColUpper[icol]-1.0e-4) {
                element[nFix]=colUpper[icol];
                index[nFix++]=icol;
                nInt++;
                if (colsol[icol]>colUpper[icol]+primalTolerance_) {
                  ifCut=true;
                  anyColumnCuts=true;
                }
              }
            }
          }
          if (nFix) {
            nTot=nFix;
            cc.setUbs(nFix,index,element);
            nFix=0;
          }
          for (istackC=0;istackC<nstackC;istackC++) {
            int icol=stackC[istackC];
            if (intVar[icol]) {
              if (colLower[icol]>currentColLower[icol]+1.0e-4) {
                element[nFix]=colLower[icol];
                index[nFix++]=icol;
                nInt++;
                if (colsol[icol]<colLower[icol]-primalTolerance_) {
                  ifCut=true;
                  anyColumnCuts=true;
                }
              }
            }
          }
          if (nFix) {
            nTot+=nFix;
            cc.setLbs(nFix,index,element);
          }
          // could tighten continuous as well
          if (nInt) {
            if (ifCut) {
              cc.setEffectiveness(100.0);
            } else {
              cc.setEffectiveness(1.0e-5);
            }
8065#ifdef CGL_DEBUG
            checkBounds(debugger,cc);
8067#endif
            cs.insert(cc);
          }
        }
        for (istackC=0;istackC<nstackC;istackC++) {
          int icol=stackC[istackC];
          if (colUpper[icol]-colLower[icol]>primalTolerance_) {
            markC[icol]=0;
          } else {
            markC[icol]=3;
          }
        }
        for (istackR=0;istackR<nstackR;istackR++) {
          int irow=stackR[istackR];
          markR[irow]=-1;
        }
      } else {
        /* is it worth seeing if can increase coefficients
           or maybe better see if it is a cut */
        if (iway==0) {
          nstackC0=CoinMin(nstackC,maxStack);
          if (notFeasible) {
            nstackC0=0;
          } else {
            for (istackC=0;istackC<nstackC0;istackC++) {
              int icol=stackC[istackC];
              stackC0[istackC]=icol;
              lo0[istackC]=colLower[icol];
              up0[istackC]=colUpper[icol];
            }
          }
          /* restore all */
          assert (iway==0)(static_cast<void> (0));
          for (istackC=nstackC-1;istackC>=0;istackC--) {
            int icol=stackC[istackC];
            double oldU=saveU[istackC];
            double oldL=saveL[istackC];
            colUpper[icol]=oldU;
            colLower[icol]=oldL;
            markC[icol]=0;
          }
          for (istackR=0;istackR<nstackR;istackR++) {
            int irow=stackR[istackR];
            // switch off strengthening if not wanted
            if ((rowCuts&2)!=0) {
              bool ifCut=anyColumnCuts;
              double gap = rowUpper[irow]-maxR[irow];
              double sum=0.0;
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                     kk++) {
                  sum += rowElements[kk]*colsol[column[kk]];
                }
                if (sum-gap*colsol[j]>maxR[irow]+primalTolerance_||info->strengthenRow) {
                  // can be a cut
                  // subtract gap from upper and integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
                  for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                       kk++) {
                    if (column[kk]!=j) {
                      index[n]=column[kk];
                      element[n++]=rowElements[kk];
                    } else {
                      double value=rowElements[kk]-gap;
                      if (fabs(value)>1.0e-12) {
                        index[n]=column[kk];
                        element[n++]=value;
                      }
                      coefficientExists=true;
                    }
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=-gap;
                  }
                  OsiRowCut rc;
                  rc.setLb(-COIN_DBL_MAX);
                  rc.setUb(rowUpper[irow]-gap*(colLower[j]+1.0));
                  // effectiveness is how far j moves
                  rc.setEffectiveness((sum-gap*colsol[j]-maxR[irow])/gap);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
8154#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
8156#endif
                    // If strengthenRow point to row
                    //if(info->strengthenRow)
                    //printf("a point to row %d\n",irow);
8160#ifdef STRENGTHEN_PRINT
      {
	printf("9Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
8184#endif
                    rowCut.addCutIfNotDuplicate(rc,irow);
                  }
                }
              }
              gap = minR[irow]-rowLower[irow];
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                if (!sum) {
                  for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                       kk++) {
                    sum += rowElements[kk]*colsol[column[kk]];
                  }
                }
                if (sum+gap*colsol[j]<minR[irow]+primalTolerance_||info->strengthenRow) {
                  // can be a cut
                  // add gap to lower and integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
                  for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                       kk++) {
                    if (column[kk]!=j) {
                      index[n]=column[kk];
                      element[n++]=rowElements[kk];
                    } else {
                      double value=rowElements[kk]+gap;
                      if (fabs(value)>1.0e-12) {
                        index[n]=column[kk];
                        element[n++]=value;
                      }
                      coefficientExists=true;
                    }
                  }
                  if (!coefficientExists) {
                    index[n]=j;
                    element[n++]=gap;
                  }
                  OsiRowCut rc;
                  rc.setLb(rowLower[irow]+gap*(colLower[j]+1.0));
                  rc.setUb(COIN_DBL_MAX);
                  // effectiveness is how far j moves
                  rc.setEffectiveness((minR[irow]-sum-gap*colsol[j])/gap);
                  if (rc.effectiveness()>needEffectiveness) {
                    rc.setRow(n,index,element,false);
8231#ifdef CGL_DEBUG
                    if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
8233#endif
                    //if(info->strengthenRow)
                    //printf("b point to row %d\n",irow);
8236#ifdef STRENGTHEN_PRINT
      {
	printf("10Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
8260#endif
                    rowCut.addCutIfNotDuplicate(rc,irow);
                  }
                }
              }
            }
            minR[irow]=saveMin[istackR];
            maxR[irow]=saveMax[istackR];
            markR[irow]=-1;
          }
        } else {
          if (iway==1&&feasible==3) {
            iway=3;
            /* point back to stack */
            for (istackC=nstackC-1;istackC>=0;istackC--) {
              int icol=stackC[istackC];
              markC[icol]=istackC+1000;
            }
            if (mode_) {
              OsiColCut cc;
              int nTot=0,nFix=0,nInt=0;
              bool ifCut=false;
              for (istackC=0;istackC<nstackC0;istackC++) {
                int icol=stackC0[istackC];
                int istackC1=markC[icol]-1000;
                if (istackC1>=0) {
                  if (CoinMin(lo0[istackC],colLower[icol])>saveL[istackC1]+1.0e-4) {
                    saveL[istackC1]=CoinMin(lo0[istackC],colLower[icol]);
                    if (intVar[icol]) {
                      element[nFix]=saveL[istackC1];
                      index[nFix++]=icol;
                      nInt++;
                      if (colsol[icol]<saveL[istackC1]-primalTolerance_)
                        ifCut=true;
                    }
                    nfixed++;
                  }
                }
              }
              if (nFix) {
                nTot=nFix;
                cc.setLbs(nFix,index,element);
                nFix=0;
              }
              for (istackC=0;istackC<nstackC0;istackC++) {
                int icol=stackC0[istackC];
                int istackC1=markC[icol]-1000;
                if (istackC1>=0) {
                  if (CoinMax(up0[istackC],colUpper[icol])<saveU[istackC1]-1.0e-4) {
                    saveU[istackC1]=CoinMax(up0[istackC],colUpper[icol]);
                    if (intVar[icol]) {
                      element[nFix]=saveU[istackC1];
                      index[nFix++]=icol;
                      nInt++;
                      if (colsol[icol]>saveU[istackC1]+primalTolerance_)
                        ifCut=true;
                    }
                    nfixed++;
                  }
                }
              }
              if (nFix) {
                nTot+=nFix;
                cc.setUbs(nFix,index,element);
              }
              // could tighten continuous as well
              if (nInt) {
                if (ifCut) {
                  cc.setEffectiveness(100.0);
                } else {
                  cc.setEffectiveness(1.0e-5);
                }
8332#ifdef CGL_DEBUG
                checkBounds(debugger,cc);
8334#endif
                cs.insert(cc);
              }
            }
          }
          /* restore all */
          for (istackC=nstackC-1;istackC>=0;istackC--) {
            int icol=stackC[istackC];
            double oldU=saveU[istackC];
            double oldL=saveL[istackC];
            colUpper[icol]=oldU;
            colLower[icol]=oldL;
            if (oldU>oldL+1.0e-4)
              markC[icol]=0;
            else
              markC[icol]=3;
          }
          for (istackR=0;istackR<nstackR;istackR++) {
            int irow=stackR[istackR];
            // switch off strengthening if not wanted
            if ((rowCuts&2)!=0) {
              bool ifCut=anyColumnCuts;
              double gap = rowUpper[irow]-maxR[irow];
              double sum=0.0;
              if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
                // see if the strengthened row is a cut
                for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                     kk++) {
                  sum += rowElements[kk]*colsol[column[kk]];
                }
                if (sum+gap*colsol[j]>rowUpper[irow]+primalTolerance_||info->strengthenRow) {
                  // can be a cut
                  // add gap to integer coefficient
                  // saveU and saveL spare
                  int * index = reinterpret_cast<int *>(saveL);
                  double * element = saveU;
                  int n=0;
                  bool coefficientExists=false;
                  for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
                       kk++) {
                    if (column[kk]!=j) {
                      index[n]=column[kk];
                      element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]+gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=gap;
      }
      OsiRowCut rc;
      rc.setLb(-COIN_DBL_MAX);
      rc.setUb(rowUpper[irow]+gap*(colUpper[j]-1.0));
      // effectiveness is how far j moves
      rc.setEffectiveness((sum+gap*colsol[j]-rowUpper[irow])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
8397#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
8399#endif
                      //if(info->strengthenRow)
                      //printf("c point to row %d\n",irow);
8402#ifdef STRENGTHEN_PRINT
      {
	printf("11Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
8426#endif
	rowCut.addCutIfNotDuplicate(rc,irow);
      }
    }
  }
  gap = minR[irow]-rowLower[irow];
  if (!ifCut&&(gap>primalTolerance_&&gap<1.0e8)) {
    // see if the strengthened row is a cut
    if (!sum) {
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	sum += rowElements[kk]*colsol[column[kk]];
      }
    }
    if (sum-gap*colsol[j]<rowLower[irow]+primalTolerance_||info->strengthenRow) {
      // can be a cut
      // subtract gap from integer coefficient
      // saveU and saveL spare
      int * index = reinterpret_cast<int *>(saveL);
      double * element = saveU;
      int n=0;
                    bool coefficientExists=false;
      for (kk=rowStart[irow];kk<rowStart[irow]+rowLength[irow];
	   kk++) {
	if (column[kk]!=j) {
	  index[n]=column[kk];
	  element[n++]=rowElements[kk];
	} else {
	  double value=rowElements[kk]-gap;
	  if (fabs(value)>1.0e-12) {
	    index[n]=column[kk];
	    element[n++]=value;
	  }
	  coefficientExists=true;
	}
      }
      if (!coefficientExists) {
	index[n]=j;
	element[n++]=-gap;
      }
      OsiRowCut rc;
      rc.setLb(rowLower[irow]-gap*(colUpper[j]-1));
      rc.setUb(COIN_DBL_MAX);
      // effectiveness is how far j moves
      rc.setEffectiveness((rowLower[irow]-sum+gap*colsol[j])/gap);
      if (rc.effectiveness()>needEffectiveness) {
	rc.setRow(n,index,element,false);
8473#ifdef CGL_DEBUG
	if (debugger) assert(!debugger->invalidCut(rc))(static_cast<void> (0)); 
8475#endif
                      //if(info->strengthenRow)
                      //printf("d point to row %d\n",irow);
8478#ifdef STRENGTHEN_PRINT
      {
	printf("12Cut %g <= ",rc.lb());
	int k;
	for ( k=0;k<n;k++) {
	  int iColumn = index[k];
	  printf("%g*",element[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rc.ub());
	printf("Row %g <= ",rowLower[irow]);
	for (k=rowStart[irow];k<rowStart[irow]+rowLength[irow];k++) {
	  int iColumn = column[k];
	  printf("%g*",rowElements[k]);
	  if (si.isInteger(iColumn))
	    printf("i%d ",iColumn);
	  else
	    printf("x%d ",iColumn);
	}
	printf("<= %g\n",rowUpper[irow]);
      }
8502#endif
	rowCut.addCutIfNotDuplicate(rc,irow);
      }
    }
  }
}
minR[irow]=saveMin[istackR];
maxR[irow]=saveMax[istackR];
markR[irow]=-1;
     }
   }
 }
      }
  }
}
delete [] stackC0;
delete [] lo0;
delete [] up0;
delete [] tempL;
delete [] tempU;
delete [] markC;
delete [] stackC;
delete [] stackR;
delete [] saveL;
delete [] saveU;
delete [] saveMin;
delete [] saveMax;
delete [] index;
delete [] element;
delete [] colsol;
// Add in row cuts
if (!ninfeas) {
  rowCut.addCuts(cs,info->strengthenRow,0);
}
delete [] array;
abort();
return (ninfeas);
8539}
8540// Create a copy of matrix which is to be used
8541// this is to speed up process and to give global cuts
8542// Can give an array with 1 set to select, 0 to ignore
8543// column bounds are tightened
8544// If array given then values of 1 will be set to 0 if redundant
8545int CglProbing::snapshot ( const OsiSolverInterface & si,
  char * possible,bool withObjective)
8547{
deleteSnapshot();
// Get basic problem information

numberColumns_=si.getNumCols(); 
numberRows_=si.getNumRows();
colLower_ = new double[numberColumns_];
colUpper_ = new double[numberColumns_];
CoinMemcpyN(si.getColLower(),numberColumns_,colLower_);
CoinMemcpyN(si.getColUpper(),numberColumns_,colUpper_);
rowLower_= new double [numberRows_+1];
rowUpper_= new double [numberRows_+1];
CoinMemcpyN(si.getRowLower(),numberRows_,rowLower_);
CoinMemcpyN(si.getRowUpper(),numberRows_,rowUpper_);

int i;
if (possible) {
  for (i=0;i<numberRows_;i++) {
    if (!possible[i]) {
rowLower_[i]=-COIN_DBL_MAX;
rowUpper_[i]=COIN_DBL_MAX;
    }
  }
}


// get integer variables
const char * intVarOriginal = si.getColType(true);
char * intVar = CoinCopyOfArray(intVarOriginal,numberColumns_);
numberIntegers_=0;
number01Integers_=0;
for (i=0;i<numberColumns_;i++) {
  if (intVar[i]) {
    numberIntegers_++;
    if (intVar[i]==1) {
      number01Integers_++;
    }
  }
}
  
rowCopy_ = new CoinPackedMatrix(*si.getMatrixByRow());

int * column = rowCopy_->getMutableIndices();
const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
const int * rowLength = rowCopy_->getVectorLengths(); 
double * rowElements = rowCopy_->getMutableElements();
// Put negative first
int * column2 = new int[numberColumns_];
double * elements2 = new double[numberColumns_];
CoinBigIndex * rowStartPos = new CoinBigIndex [numberRows_];
for (int i=0;i<numberRows_;i++) {
  CoinBigIndex start = rowStart[i];
  CoinBigIndex end = start + rowLength[i];
  int nOther=0;
  for (CoinBigIndex j=start; j<end ; j++) { 
    int iColumn = column[j];
    double value = rowElements[j];
    if (value<0.0) {
rowElements[start]=value;
column[start++]=iColumn;
    } else {
elements2[nOther]=value;
column2[nOther++]=iColumn;
    }
  }
  rowStartPos[i] = start;
  for (int k=0;k<nOther;k++) {
    rowElements[start]=elements2[k];
    column[start++]=column2[k];
  }
}
delete [] column2;
delete [] elements2;

int returnCode=0;
int ninfeas= 
  tighten(colLower_, colUpper_, column, rowElements,
   rowStart, NULL__null,rowLength, rowLower_, rowUpper_,
   numberRows_, numberColumns_, intVar, 5, primalTolerance_);
delete [] rowStartPos;
if (ninfeas) {
  // let someone else find out
  returnCode = 1;
}
8631/*
QUESTION: If ninfeas > 1 (one or more variables infeasible), shouldn't we
   bail out here?
8634*/

// do integer stuff for mode 0
cutVector_ = new disaggregation [number01Integers_];
memset(cutVector_,0,number01Integers_*sizeof(disaggregation));
number01Integers_=0;
for (i=0;i<numberColumns_;i++) {
  if (intVar[i]==1)
    cutVector_[number01Integers_++].sequence=i;
}
delete [] intVar;

// now delete rows
if (possible) {
  for (i=0;i<numberRows_;i++) {
    if (rowLower_[i]<-1.0e30&&rowUpper_[i]>1.0e30) 
possible[i]=0;
  }
}
int * index = new int[numberRows_];
int nDrop=0,nKeep=0;
for (i=0;i<numberRows_;i++) {
  if (rowLower_[i]<-1.0e30&&rowUpper_[i]>1.0e30) {
    index[nDrop++]=i;
  } else {
    rowLower_[nKeep]=rowLower_[i];
    rowUpper_[nKeep++]=rowUpper_[i];
  }
}
numberRows_=nKeep;
if (nDrop)
  rowCopy_->deleteRows(nDrop,index);
delete [] index;
if (withObjective) {
  // add in objective 
  int * columns = new int[numberColumns_];
  double * elements = new double[numberColumns_];
  int n=0;
  const double * objective = si.getObjCoefficients();
  bool maximize = (si.getObjSense()==-1);
  for (i=0;i<numberColumns_;i++) {
    if (objective[i]) {
      elements[n]= (maximize) ? -objective[i] : objective[i];
      columns[n++]=i;
    }
  }
  rowCopy_->appendRow(n,columns,elements);
  delete [] columns;
  delete [] elements;
  numberRows_++;
}
// create column copy
if (rowCopy_->getNumElements()) {
  columnCopy_=new CoinPackedMatrix(*rowCopy_,0,0,true);
} else {
  columnCopy_=new CoinPackedMatrix();
}
// make sure big enough - in case too many rows dropped
columnCopy_->setDimensions(numberRows_,numberColumns_);
rowCopy_->setDimensions(numberRows_,numberColumns_);
return returnCode;
8695}
8696// Delete snapshot
8697void CglProbing::deleteSnapshot()
8698{
delete [] rowLower_;
delete [] rowUpper_;
delete [] colLower_;
delete [] colUpper_;
delete rowCopy_;
delete columnCopy_;
rowCopy_=NULL__null;
columnCopy_=NULL__null;
rowLower_=NULL__null;
rowUpper_=NULL__null;
colLower_=NULL__null;
colUpper_=NULL__null;
int i;
for (i=0;i<number01Integers_;i++) {
  delete [] cutVector_[i].index;
}
delete [] cutVector_;
numberIntegers_=0;
number01Integers_=0;
cutVector_=NULL__null;
8719}
8720// Mode stuff
8721void CglProbing::setMode(int mode)
8722{
if (mode>=0&&mode<3) {
  // take off bottom bit
  mode_ &= ~15;
  mode_ |= mode;
}
8728}
8729int CglProbing::getMode() const
8730{
return mode_&15;
8732}
8733// Set maximum number of passes per node
8734void CglProbing::setMaxPass(int value)
8735{
if (value>0)
  maxPass_=value;
8738}
8739// Get maximum number of passes per node
8740int CglProbing::getMaxPass() const
8741{
return maxPass_;
8743}
8744// Set log level
8745void CglProbing::setLogLevel(int value)
8746{
if (value>=0)
  logLevel_=value;
8749}
8750// Get log level
8751int CglProbing::getLogLevel() const
8752{
return logLevel_;
8754}
8755// Set maximum number of unsatisfied variables to look at
8756void CglProbing::setMaxProbe(int value)
8757{
if (value>=0)
  maxProbe_=value;
8760}
8761// Get maximum number of unsatisfied variables to look at
8762int CglProbing::getMaxProbe() const
8763{
return maxProbe_;
8765}
8766// Set maximum number of variables to look at in one probe
8767void CglProbing::setMaxLook(int value)
8768{
if (value>=0)
  maxStack_=value;
8771}
8772// Get maximum number of variables to look at in one probe
8773int CglProbing::getMaxLook() const
8774{
return maxStack_;
8776}
8777// Set maximum number of elements in row for scan
8778void CglProbing::setMaxElements(int value)
8779{
if (value>0)
  maxElements_=value;
8782}
8783// Get maximum number of elements in row for scan
8784int CglProbing::getMaxElements() const
8785{
return maxElements_;
8787}
8788// Set maximum number of passes per node (root node)
8789void CglProbing::setMaxPassRoot(int value)
8790{
if (value>0)
  maxPassRoot_=value;
8793}
8794// Get maximum number of passes per node (root node)
8795int CglProbing::getMaxPassRoot() const
8796{
return maxPassRoot_;
8798}
8799// Set maximum number of unsatisfied variables to look at (root node)
8800void CglProbing::setMaxProbeRoot(int value)
8801{
if (value>0)
  maxProbeRoot_=value;
8804}
8805// Get maximum number of unsatisfied variables to look at (root node)
8806int CglProbing::getMaxProbeRoot() const
8807{
return maxProbeRoot_;
8809}
8810// Set maximum number of variables to look at in one probe (root node)
8811void CglProbing::setMaxLookRoot(int value)
8812{
if (value>0)
  maxStackRoot_=value;
8815}
8816// Get maximum number of variables to look at in one probe (root node)
8817int CglProbing::getMaxLookRoot() const
8818{
return maxStackRoot_;
8820}
8821// Set maximum number of elements in row for scan (root node)
8822void CglProbing::setMaxElementsRoot(int value)
8823{
if (value>0)
  maxElementsRoot_=value;
8826}
8827// Get maximum number of elements in row for scan (root node)
8828int CglProbing::getMaxElementsRoot() const
8829{
return maxElementsRoot_;
8831}
8832// Set whether to use objective
8833void CglProbing::setUsingObjective(int yesNo)
8834{
usingObjective_=yesNo;
8836}
8837// Get whether objective is being used
8838int CglProbing::getUsingObjective() const
8839{
return usingObjective_;
8841}
8842// Decide whether to do row cuts
8843void CglProbing::setRowCuts(int type)
8844{
if (type>-5&&type<5)
  rowCuts_=type;
8847}
8848// Returns row cuts generation type
8849int CglProbing::rowCuts() const
8850{
return rowCuts_;
8852}
8853// Returns tight lower
8854const double * CglProbing::tightLower() const
8855{
return colLower_;
8857}
8858// Returns tight upper
8859const double * CglProbing::tightUpper() const
8860{
return colUpper_;
8862}
8863// Returns relaxed Row lower
8864const double * CglProbing::relaxedRowLower() const
8865{
return rowLower_;
8867}
8868// Returns relaxed Row upper
8869const double * CglProbing::relaxedRowUpper() const
8870{
return rowUpper_;
8872}


8875//-------------------------------------------------------------------
8876// Default Constructor 
8877//-------------------------------------------------------------------
8878CglProbing::CglProbing ()

8880CglCutGenerator(),
8881primalTolerance_(1.0e-07),
8882mode_(1),
8883rowCuts_(1),
8884maxPass_(3),
8885logLevel_(0),
8886maxProbe_(100),
8887maxStack_(50),
8888maxElements_(1000),
8889maxPassRoot_(3),
8890maxProbeRoot_(100),
8891maxStackRoot_(50),
8892maxElementsRoot_(10000),
8893usingObjective_(0)
8894{

numberRows_=0;
numberColumns_=0;
rowCopy_=NULL__null;
columnCopy_=NULL__null;
rowLower_=NULL__null;
rowUpper_=NULL__null;
colLower_=NULL__null;
colUpper_=NULL__null;
numberIntegers_=0;
number01Integers_=0;
numberThisTime_=0;
totalTimesCalled_=0;
lookedAt_=NULL__null;
cutVector_=NULL__null;
numberCliques_=0;
cliqueType_=NULL__null;
cliqueStart_=NULL__null;
cliqueEntry_=NULL__null;
oneFixStart_=NULL__null;
zeroFixStart_=NULL__null;
endFixStart_=NULL__null;
whichClique_=NULL__null;
cliqueRow_=NULL__null;
cliqueRowStart_=NULL__null;
tightenBounds_=NULL__null;
8921}

8923//-------------------------------------------------------------------
8924// Copy constructor 
8925//-------------------------------------------------------------------
8926CglProbing::CglProbing (  const CglProbing & rhs)
                                                            :
CglCutGenerator(rhs),
primalTolerance_(rhs.primalTolerance_),
mode_(rhs.mode_),
rowCuts_(rhs.rowCuts_),
maxPass_(rhs.maxPass_),
logLevel_(rhs.logLevel_),
maxProbe_(rhs.maxProbe_),
maxStack_(rhs.maxStack_),
maxElements_(rhs.maxElements_),
maxPassRoot_(rhs.maxPassRoot_),
maxProbeRoot_(rhs.maxProbeRoot_),
maxStackRoot_(rhs.maxStackRoot_),
maxElementsRoot_(rhs.maxElementsRoot_),
usingObjective_(rhs.usingObjective_)
8942{  
numberRows_=rhs.numberRows_;
numberColumns_=rhs.numberColumns_;
numberCliques_=rhs.numberCliques_;
if (rhs.rowCopy_) {
  rowCopy_= new CoinPackedMatrix(*(rhs.rowCopy_));
  columnCopy_= new CoinPackedMatrix(*(rhs.columnCopy_));
  rowLower_=new double[numberRows_];
  CoinMemcpyN(rhs.rowLower_,numberRows_,rowLower_);
  rowUpper_=new double[numberRows_];
  CoinMemcpyN(rhs.rowUpper_,numberRows_,rowUpper_);
  colLower_=new double[numberColumns_];
  CoinMemcpyN(rhs.colLower_,numberColumns_,colLower_);
  colUpper_=new double[numberColumns_];
  CoinMemcpyN(rhs.colUpper_,numberColumns_,colUpper_);
  int i;
  numberIntegers_=rhs.numberIntegers_;
  number01Integers_=rhs.number01Integers_;
  cutVector_=new disaggregation [number01Integers_];
  CoinMemcpyN(rhs.cutVector_,number01Integers_,cutVector_);
  for (i=0;i<number01Integers_;i++) {
    if (cutVector_[i].index) {
cutVector_[i].index = CoinCopyOfArray(rhs.cutVector_[i].index,cutVector_[i].length);
    }
  }
} else {
  rowCopy_=NULL__null;
  columnCopy_=NULL__null;
  rowLower_=NULL__null;
  rowUpper_=NULL__null;
  colLower_=NULL__null;
  colUpper_=NULL__null;
  numberIntegers_=0;
  number01Integers_=0;
  cutVector_=NULL__null;
}
numberThisTime_=rhs.numberThisTime_;
totalTimesCalled_=rhs.totalTimesCalled_;
if (numberColumns_)
  lookedAt_=CoinCopyOfArray(rhs.lookedAt_,numberColumns_);
else
  lookedAt_ = NULL__null;
if (numberCliques_) {
  cliqueType_ = new cliqueType [numberCliques_];
  CoinMemcpyN(rhs.cliqueType_,numberCliques_,cliqueType_);
  cliqueStart_ = new int [numberCliques_+1];
  CoinMemcpyN(rhs.cliqueStart_,(numberCliques_+1),cliqueStart_);
  int n = cliqueStart_[numberCliques_];
  cliqueEntry_ = new cliqueEntry [n];
  CoinMemcpyN(rhs.cliqueEntry_,n,cliqueEntry_);
  oneFixStart_ = new int [numberColumns_];
  CoinMemcpyN(rhs.oneFixStart_,numberColumns_,oneFixStart_);
  zeroFixStart_ = new int [numberColumns_];
  CoinMemcpyN(rhs.zeroFixStart_,numberColumns_,zeroFixStart_);
  endFixStart_ = new int [numberColumns_];
  CoinMemcpyN(rhs.endFixStart_,numberColumns_,endFixStart_);
8998#ifndef NDEBUG1
  int n2=-1;
  for (int i=numberColumns_-1;i>=0;i--) {
    if (oneFixStart_[i]>=0) {
n2=endFixStart_[i];
break;
    }
  }
  assert (n==n2)(static_cast<void> (0));
9007#endif
  whichClique_ = new int [n];
  CoinMemcpyN(rhs.whichClique_,n,whichClique_);
  if (rhs.cliqueRowStart_) {
    cliqueRowStart_ = CoinCopyOfArray(rhs.cliqueRowStart_,numberRows_+1);
    n=cliqueRowStart_[numberRows_];
    cliqueRow_ = CoinCopyOfArray(rhs.cliqueRow_,n);
  } else {
    cliqueRow_=NULL__null;
    cliqueRowStart_=NULL__null;
  }
} else {
  cliqueType_=NULL__null;
  cliqueStart_=NULL__null;
  cliqueEntry_=NULL__null;
  oneFixStart_=NULL__null;
  zeroFixStart_=NULL__null;
  endFixStart_=NULL__null;
  cliqueRow_=NULL__null;
  cliqueRowStart_=NULL__null;
  whichClique_=NULL__null;
}
if (rhs.tightenBounds_) {
  assert (numberColumns_)(static_cast<void> (0));
  tightenBounds_=CoinCopyOfArray(rhs.tightenBounds_,numberColumns_);
} else {
  tightenBounds_=NULL__null;
}
9035}

9037//-------------------------------------------------------------------
9038// Clone
9039//-------------------------------------------------------------------
9040CglCutGenerator *
9041CglProbing::clone() const
9042{
return new CglProbing(*this);
9044}

9046//-------------------------------------------------------------------
9047// Destructor 
9048//-------------------------------------------------------------------
9049CglProbing::~CglProbing ()
9050{
// free memory
delete [] rowLower_;
delete [] rowUpper_;
delete [] colLower_;
delete [] colUpper_;
delete rowCopy_;
delete columnCopy_;
delete [] lookedAt_;
delete [] cliqueType_;
delete [] cliqueStart_;
delete [] cliqueEntry_;
delete [] oneFixStart_;
delete [] zeroFixStart_;
delete [] endFixStart_;
delete [] whichClique_;
delete [] cliqueRow_;
delete [] cliqueRowStart_;
if (cutVector_) {
  for (int i=0;i<number01Integers_;i++) {
    delete [] cutVector_[i].index;
  }
  delete [] cutVector_;
}
delete [] tightenBounds_;
9075}

9077//----------------------------------------------------------------
9078// Assignment operator 
9079//-------------------------------------------------------------------
9080CglProbing &
9081CglProbing::operator=(
                                       const CglProbing& rhs)
9083{
if (this != &rhs) {
  CglCutGenerator::operator=(rhs);
  primalTolerance_=rhs.primalTolerance_;
  numberRows_=rhs.numberRows_;
  numberColumns_=rhs.numberColumns_;
  delete [] rowLower_;
  delete [] rowUpper_;
  delete [] colLower_;
  delete [] colUpper_;
  delete rowCopy_;
  delete columnCopy_;
  delete [] lookedAt_;
  delete [] cliqueType_;
  delete [] cliqueStart_;
  delete [] cliqueEntry_;
  delete [] oneFixStart_;
  delete [] zeroFixStart_;
  delete [] endFixStart_;
  delete [] whichClique_;
  delete [] cliqueRow_;
  delete [] cliqueRowStart_;
  delete [] tightenBounds_;
  mode_=rhs.mode_;
  rowCuts_=rhs.rowCuts_;
  maxPass_=rhs.maxPass_;
  logLevel_=rhs.logLevel_;
  maxProbe_=rhs.maxProbe_;
  maxStack_=rhs.maxStack_;
  maxElements_ = rhs.maxElements_;
  maxPassRoot_ = rhs.maxPassRoot_;
  maxProbeRoot_ = rhs.maxProbeRoot_;
  maxStackRoot_ = rhs.maxStackRoot_;
  maxElementsRoot_ = rhs.maxElementsRoot_;
  usingObjective_=rhs.usingObjective_;
  numberCliques_=rhs.numberCliques_;
  if (rhs.rowCopy_) {
    rowCopy_= new CoinPackedMatrix(*(rhs.rowCopy_));
    columnCopy_= new CoinPackedMatrix(*(rhs.columnCopy_));
    rowLower_=new double[numberRows_];
    CoinMemcpyN(rhs.rowLower_,numberRows_,rowLower_);
    rowUpper_=new double[numberRows_];
    CoinMemcpyN(rhs.rowUpper_,numberRows_,rowUpper_);
    colLower_=new double[numberColumns_];
    CoinMemcpyN(rhs.colLower_,numberColumns_,colLower_);
    colUpper_=new double[numberColumns_];
    CoinMemcpyN(rhs.colUpper_,numberColumns_,colUpper_);
    int i;
    numberIntegers_=rhs.numberIntegers_;
    number01Integers_=rhs.number01Integers_;
    for (i=0;i<number01Integers_;i++) {
      delete [] cutVector_[i].index;
    }
    delete [] cutVector_;
    cutVector_=new disaggregation [number01Integers_];
    CoinMemcpyN(rhs.cutVector_,number01Integers_,cutVector_);
    for (i=0;i<number01Integers_;i++) {
      if (cutVector_[i].index) {
        cutVector_[i].index = CoinCopyOfArray(rhs.cutVector_[i].index,cutVector_[i].length);
      }
    }
  } else {
    rowCopy_=NULL__null;
    columnCopy_=NULL__null;
    rowLower_=NULL__null;
    rowUpper_=NULL__null;
    colLower_=NULL__null;
    colUpper_=NULL__null;
    numberIntegers_=0;
    number01Integers_=0;
    cutVector_=NULL__null;
  }
  numberThisTime_=rhs.numberThisTime_;
  totalTimesCalled_=rhs.totalTimesCalled_;
  if (numberColumns_)
    lookedAt_=CoinCopyOfArray(rhs.lookedAt_,numberColumns_);
  else
    lookedAt_ = NULL__null;
  if (numberCliques_) {
    cliqueType_ = new cliqueType [numberCliques_];
    CoinMemcpyN(rhs.cliqueType_,numberCliques_,cliqueType_);
    cliqueStart_ = new int [numberCliques_+1];
    CoinMemcpyN(rhs.cliqueStart_,(numberCliques_+1),cliqueStart_);
    int n = cliqueStart_[numberCliques_];
    cliqueEntry_ = new cliqueEntry [n];
    CoinMemcpyN(rhs.cliqueEntry_,n,cliqueEntry_);
    oneFixStart_ = new int [numberColumns_];
    CoinMemcpyN(rhs.oneFixStart_,numberColumns_,oneFixStart_);
    zeroFixStart_ = new int [numberColumns_];
    CoinMemcpyN(rhs.zeroFixStart_,numberColumns_,zeroFixStart_);
    endFixStart_ = new int [numberColumns_];
    CoinMemcpyN(rhs.endFixStart_,numberColumns_,endFixStart_);
9175#ifndef NDEBUG1
    int n2=-1;
    for (int i=numberColumns_-1;i>=0;i--) {
if (oneFixStart_[i]>=0) {
 n2=endFixStart_[i];
 break;
}
    }
    assert (n==n2)(static_cast<void> (0));
9184#endif
    whichClique_ = new int [n];
    CoinMemcpyN(rhs.whichClique_,n,whichClique_);
    if (rhs.cliqueRowStart_) {
      cliqueRowStart_ = CoinCopyOfArray(rhs.cliqueRowStart_,numberRows_+1);
      n=cliqueRowStart_[numberRows_];
      cliqueRow_ = CoinCopyOfArray(rhs.cliqueRow_,n);
    } else {
      cliqueRow_=NULL__null;
      cliqueRowStart_=NULL__null;
    }
  } else {
    cliqueType_=NULL__null;
    cliqueStart_=NULL__null;
    cliqueEntry_=NULL__null;
    oneFixStart_=NULL__null;
    zeroFixStart_=NULL__null;
    endFixStart_=NULL__null;
    whichClique_=NULL__null;
    cliqueRow_=NULL__null;
    cliqueRowStart_=NULL__null;
  }
  if (rhs.tightenBounds_) {
    assert (numberColumns_)(static_cast<void> (0));
    tightenBounds_=CoinCopyOfArray(rhs.tightenBounds_,numberColumns_);
  } else {
    tightenBounds_=NULL__null;
  }
}
return *this;
9214}

9216/// This can be used to refresh any inforamtion
9217void 
9218CglProbing::refreshSolver(OsiSolverInterface * solver)
9219{
if (rowCopy_) {
  // snapshot existed - redo
  snapshot(*solver,NULL__null);
}
9224}
9225/* Creates cliques for use by probing.
 Can also try and extend cliques as a result of probing (root node).
 Returns number of cliques found.
9228*/
9229int 
9230CglProbing::createCliques( OsiSolverInterface & si, 
	  int minimumSize, int maximumSize)
9232{
// get rid of what is there
deleteCliques();
CoinPackedMatrix matrixByRow(*si.getMatrixByRow());
int numberRows = si.getNumRows();
if (!rowCopy_)
  numberRows_=numberRows;
numberColumns_ = si.getNumCols();

numberCliques_=0;
int numberEntries=0;
int numberIntegers=0;
int * lookup = new int[numberColumns_];
int i;
for (i=0;i<numberColumns_;i++) {
  if (si.isBinary(i))
    lookup[i]=numberIntegers++;
  else
    lookup[i]=-1;
}

int * which = new int[numberColumns_];
int * whichRow = new int[numberRows];
// Statistics
int totalP1=0,totalM1=0;
int numberBig=0,totalBig=0;
int numberFixed=0;

// Row copy
const double * elementByRow = matrixByRow.getElements();
const int * column = matrixByRow.getIndices();
const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
const int * rowLength = matrixByRow.getVectorLengths();

const double * lower = si.getColLower();
const double * upper = si.getColUpper();
const double * rowLower = si.getRowLower();
const double * rowUpper = si.getRowUpper();
int iRow;
for (iRow=0;iRow<numberRows;iRow++) {
  int numberP1=0, numberM1=0;
  int j;
  double upperValue=rowUpper[iRow];
  double lowerValue=rowLower[iRow];
  bool good=true;
  for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    int iColumn = column[j];
    int iInteger=lookup[iColumn];
    if (upper[iColumn]-lower[iColumn]<1.0e-8) {
// fixed
upperValue -= lower[iColumn]*elementByRow[j];
lowerValue -= lower[iColumn]*elementByRow[j];
continue;
    } else if (upper[iColumn]!=1.0||lower[iColumn]!=0.0) {
good = false;
break;
    } else if (iInteger<0) {
good = false;
break;
    }
    if (fabs(elementByRow[j])!=1.0) {
good=false;
break;
    } else if (elementByRow[j]>0.0) {
which[numberP1++]=iColumn;
    } else {
numberM1++;
which[numberIntegers-numberM1]=iColumn;
    }
  }
  int iUpper = static_cast<int> (floor(upperValue+1.0e-5));
  int iLower = static_cast<int> (ceil(lowerValue-1.0e-5));
  int state=0;
  if (upperValue<1.0e6) {
    if (iUpper==1-numberM1)
state=1;
    else if (iUpper==-numberM1)
state=2;
    else if (iUpper<-numberM1)
state=3;
  }
  if (!state&&lowerValue>-1.0e6) {
    if (-iLower==1-numberP1)
state=-1;
    else if (-iLower==-numberP1)
state=-2;
    else if (-iLower<-numberP1)
state=-3;
  }
  if (good&&state) {
    if (abs(state)==3) {
// infeasible
numberCliques_ = -99999;
break;
    } else if (abs(state)==2) {
// we can fix all
numberFixed += numberP1+numberM1;
if (state>0) {
 // fix all +1 at 0, -1 at 1
 for (i=0;i<numberP1;i++)
   si.setColUpper(which[i],0.0);
 for (i=0;i<numberM1;i++)
   si.setColLower(which[numberIntegers-i-1],
		 1.0);
} else {
 // fix all +1 at 1, -1 at 0
 for (i=0;i<numberP1;i++)
   si.setColLower(which[i],1.0);
 for (i=0;i<numberM1;i++)
   si.setColUpper(which[numberIntegers-i-1],
		 0.0);
}
    } else {
int length = numberP1+numberM1;
      totalP1 += numberP1;
      totalM1 += numberM1;
if (length >= minimumSize&&length<maximumSize) {
 whichRow[numberCliques_++]=iRow;
 numberEntries += length;
} else if (numberP1+numberM1 >= maximumSize) {
 // too big
 numberBig++;
 totalBig += numberP1+numberM1;
}
    }
  }
}
if (numberCliques_<0) {
  if (logLevel_)
    printf("*** Problem infeasible\n");
} else {
  if (numberCliques_) {
    if (logLevel_)
      printf("%d cliques of average size %g found, %d P1, %d M1\n",
             numberCliques_,
             (static_cast<double>(totalP1+totalM1))/
      (static_cast<double> (numberCliques_)),
             totalP1,totalM1);
  } else {
    if (logLevel_>1)
      printf("No cliques found\n");
  }
  if (numberBig) {
    if (logLevel_)
      printf("%d large cliques ( >= %d) found, total %d\n",
    numberBig,maximumSize,totalBig);
  }
  if (numberFixed) {
    if (logLevel_)
      printf("%d variables fixed\n",numberFixed);
  }
}
if (numberCliques_>0) {
  cliqueType_ = new cliqueType [numberCliques_];
  cliqueStart_ = new int [numberCliques_+1];
  cliqueEntry_ = new cliqueEntry [numberEntries];
  oneFixStart_ = new int [numberColumns_];
  zeroFixStart_ = new int [numberColumns_];
  endFixStart_ = new int [numberColumns_];
  whichClique_ = new int [numberEntries];
  numberEntries=0;
  cliqueStart_[0]=0;
  for (i=0;i<numberColumns_;i++) {
    oneFixStart_[i]=-1;
    zeroFixStart_[i]=-1;
    endFixStart_[i]=-1;
  }
  int iClique;
  // Possible some have been fixed
  int numberCliques=numberCliques_;
  numberCliques_=0;
  for (iClique=0;iClique<numberCliques;iClique++) {
    int iRow=whichRow[iClique];
    whichRow[numberCliques_]=iRow;
    int numberP1=0, numberM1=0;
    int j;
    double upperValue=rowUpper[iRow];
    double lowerValue=rowLower[iRow];
    for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
int iColumn = column[j];
if (upper[iColumn]-lower[iColumn]<1.0e-8) {
 // fixed
 upperValue -= lower[iColumn]*elementByRow[j];
 lowerValue -= lower[iColumn]*elementByRow[j];
 continue;
}
if (elementByRow[j]>0.0) {
 which[numberP1++]=iColumn;
} else {
 numberM1++;
 which[numberIntegers-numberM1]=iColumn;
}
    }
    int iUpper = static_cast<int> (floor(upperValue+1.0e-5));
    int iLower = static_cast<int> (ceil(lowerValue-1.0e-5));
    int state=0;
    if (upperValue<1.0e6) {
if (iUpper==1-numberM1)
 state=1;
    }
    if (!state&&lowerValue>-1.0e6) {
state=-1;
    }
    if (abs(state)!=1)
continue; // must have been fixed
    if (iLower==iUpper) {
cliqueType_[numberCliques_].equality=1;
    } else {
cliqueType_[numberCliques_].equality=0;
    }
    if (state>0) {
for (i=0;i<numberP1;i++) {
 // 1 is strong branch
 int iColumn = which[i];
 setSequenceInCliqueEntry(cliqueEntry_[numberEntries],iColumn);
 setOneFixesInCliqueEntry(cliqueEntry_[numberEntries],true);
 numberEntries++;
 // zero counts
 oneFixStart_[iColumn]=0;
 zeroFixStart_[iColumn]=0;
}
for (i=0;i<numberM1;i++) {
 // 0 is strong branch
 int iColumn = which[numberIntegers-i-1];
 setSequenceInCliqueEntry(cliqueEntry_[numberEntries],iColumn);
 setOneFixesInCliqueEntry(cliqueEntry_[numberEntries],false);
 numberEntries++;
 // zero counts
 oneFixStart_[iColumn]=0;
 zeroFixStart_[iColumn]=0;
}
    } else {
for (i=0;i<numberP1;i++) {
 // 0 is strong branch
 int iColumn = which[i];
 setSequenceInCliqueEntry(cliqueEntry_[numberEntries],iColumn);
 setOneFixesInCliqueEntry(cliqueEntry_[numberEntries],false);
 numberEntries++;
 // zero counts
 oneFixStart_[iColumn]=0;
 zeroFixStart_[iColumn]=0;
}
for (i=0;i<numberM1;i++) {
 // 1 is strong branch
 int iColumn = which[numberIntegers-i-1];
 setSequenceInCliqueEntry(cliqueEntry_[numberEntries],iColumn);
 setOneFixesInCliqueEntry(cliqueEntry_[numberEntries],true);
 numberEntries++;
 // zero counts
 oneFixStart_[iColumn]=0;
 zeroFixStart_[iColumn]=0;
}
    }
    numberCliques_++;
    cliqueStart_[numberCliques_]=numberEntries;
  }
  // Now do column lists
  // First do counts
  for (iClique=0;iClique<numberCliques_;iClique++) {
    for (int j=cliqueStart_[iClique];j<cliqueStart_[iClique+1];j++) {
int iColumn = sequenceInCliqueEntry(cliqueEntry_[j]);
if (oneFixesInCliqueEntry(cliqueEntry_[j]))
 oneFixStart_[iColumn]++;
else
 zeroFixStart_[iColumn]++;
    }
  }
  // now get starts and use which and end as counters
  numberEntries=0;
  for (int iColumn=0;iColumn<numberColumns_;iColumn++) {
    if (oneFixStart_[iColumn]>=0) {
int n1=oneFixStart_[iColumn];
int n2=zeroFixStart_[iColumn];
oneFixStart_[iColumn]=numberEntries;
which[iColumn]=numberEntries;
numberEntries += n1;
zeroFixStart_[iColumn]=numberEntries;
endFixStart_[iColumn]=numberEntries;
numberEntries += n2;
    }
  }
  // now put in
  for (iClique=0;iClique<numberCliques_;iClique++) {
    for (int j=cliqueStart_[iClique];j<cliqueStart_[iClique+1];j++) {
int iColumn = sequenceInCliqueEntry(cliqueEntry_[j]);
if (oneFixesInCliqueEntry(cliqueEntry_[j])) {
 int put = which[iColumn];
 which[iColumn]++;
 whichClique_[put]=iClique;
} else {
 int put = endFixStart_[iColumn];
 endFixStart_[iColumn]++;
 whichClique_[put]=iClique;
}
    }
  }
}
delete [] which;
delete [] whichRow;
delete [] lookup;
return numberCliques_;
9533}
9534// Delete all clique information
9535void 
9536CglProbing::deleteCliques()
9537{
delete [] cliqueType_;
delete [] cliqueStart_;
delete [] cliqueEntry_;
delete [] oneFixStart_;
delete [] zeroFixStart_;
delete [] endFixStart_;
delete [] whichClique_;
delete [] cliqueRow_;
delete [] cliqueRowStart_;
cliqueType_=NULL__null;
cliqueStart_=NULL__null;
cliqueEntry_=NULL__null;
oneFixStart_=NULL__null;
zeroFixStart_=NULL__null;
endFixStart_=NULL__null;
whichClique_=NULL__null;
cliqueRow_=NULL__null;
cliqueRowStart_=NULL__null;
numberCliques_=0;
9557}
9558/*
Returns true if may generate Row cuts in tree (rather than root node).
Used so know if matrix will change in tree.  Really
meant so column cut generators can still be active
without worrying code.
Default is true
9564*/
9565bool 
9566CglProbing::mayGenerateRowCutsInTree() const
9567{
return rowCuts_>0;
9569}
9570// Sets up clique information for each row
9571void 
9572CglProbing::setupRowCliqueInformation(const OsiSolverInterface & si) 
9573{
if (!numberCliques_)
  return;
CoinPackedMatrix * rowCopy;
if (!rowCopy_) {
  // create from current
  numberRows_=si.getNumRows(); 
  numberColumns_=si.getNumCols(); 
  rowCopy = new CoinPackedMatrix(*si.getMatrixByRow());
} else {
  rowCopy = rowCopy_;
  assert(numberRows_<=si.getNumRows())(static_cast<void> (0)); 
  assert(numberColumns_==si.getNumCols())(static_cast<void> (0)); 
}
assert(numberRows_&&numberColumns_)(static_cast<void> (0));
cliqueRowStart_ = new int [numberRows_+1];
cliqueRowStart_[0]=0;
// Temporary array while building list
cliqueEntry ** array = new cliqueEntry * [numberRows_];
// Which cliques in use
int * which = new int[numberCliques_];
int * count = new int[numberCliques_];
int * back =new int[numberColumns_];
CoinZeroN(count,numberCliques_);
CoinFillN(back,numberColumns_,-1);
const int * column = rowCopy->getIndices();
const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
const int * rowLength = rowCopy->getVectorLengths(); 
const double * lower = si.getColLower();
const double * upper = si.getColUpper();
int iRow;
for (iRow=0;iRow<numberRows_;iRow++) {
  int j;
  int numberFree=0;
  int numberUsed=0;
  for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    int iColumn=column[j];
    if (upper[iColumn]>lower[iColumn]) {
      back[iColumn]=j-rowStart[iRow];
      numberFree++;
      for (int k=oneFixStart_[iColumn];k<endFixStart_[iColumn];k++) {
        int iClique = whichClique_[k];
        if (!count[iClique]) {
          which[numberUsed++]=iClique;
        }
        count[iClique]++;
      }
    }
  }
  // find largest cliques
  bool finished=false;
  int numberInThis=0;
  cliqueEntry * entries = NULL__null;
  array[iRow]=entries;
  while (!finished) {
    int largest=1;
    int whichClique=-1;
    for (int i=0;i<numberUsed;i++) {
      int iClique = which[i];
      if (count[iClique]>largest) {
        largest=count[iClique];
        whichClique=iClique;
      }
    }
    // Add in if >1 (but not if all as that means clique==row)
    if (whichClique>=0&&largest<numberFree) {
      if (!numberInThis) {
        int length=rowLength[iRow];
        entries = new cliqueEntry [length];
        array[iRow]=entries;
        for (int i=0;i<length;i++) {
          setOneFixesInCliqueEntry(entries[i],false);
          setSequenceInCliqueEntry(entries[i],numberColumns_+1);
        }
      }
      // put in (and take out all counts)
      for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
        int iColumn=column[j];
        if (upper[iColumn]>lower[iColumn]) {
          bool found=false;
          int k;
          for ( k=oneFixStart_[iColumn];k<endFixStart_[iColumn];k++) {
            int iClique = whichClique_[k];
            if (iClique==whichClique) {
              found=true;
              break;
            }
          }
          if (found) {
            for ( k=oneFixStart_[iColumn];k<endFixStart_[iColumn];k++) {
              int iClique = whichClique_[k];
              count[iClique]--;
            }
            for (k=cliqueStart_[whichClique];k<cliqueStart_[whichClique+1];k++) {
              if (sequenceInCliqueEntry(cliqueEntry_[k])==iColumn) {
                int iback=back[iColumn];
                setSequenceInCliqueEntry(entries[iback],numberInThis);
                setOneFixesInCliqueEntry(entries[iback],
			   oneFixesInCliqueEntry(cliqueEntry_[k]));
                break;
              }
            }
          }
        }
      }
      numberInThis++;
    } else {
      finished=true;
    }
  }
  if (numberInThis) 
    cliqueRowStart_[iRow+1]=cliqueRowStart_[iRow]+rowLength[iRow];
  else
    cliqueRowStart_[iRow+1]=cliqueRowStart_[iRow];
  for (int i=0;i<numberUsed;i++) {
    int iClique = which[i];
    count[iClique]=0;
  }
  for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    int iColumn=column[j];
    back[iColumn]=-1;
  }
}
delete [] which;
delete [] count;
delete [] back;
// Now put info in one array
cliqueRow_ = new cliqueEntry [cliqueRowStart_[numberRows_]];
for (iRow=0;iRow<numberRows_;iRow++) {
  if (array[iRow]) {
    int start = cliqueRowStart_[iRow];
    CoinMemcpyN(array[iRow],rowLength[iRow],cliqueRow_+start);
    delete [] array[iRow];
  }
}
delete [] array;
if (rowCopy!=rowCopy_)
  delete rowCopy;
9711}
9712// Mark variables to be tightened
9713void 
9714CglProbing::tightenThese(const OsiSolverInterface & solver,int number, const int * which)
9715{
delete [] tightenBounds_;
int numberColumns = solver.getNumCols();
if (numberColumns_)
  assert (numberColumns_==numberColumns)(static_cast<void> (0));
tightenBounds_ = new char [numberColumns];
memset(tightenBounds_,0,numberColumns);
for (int i=0;i<number;i++) {
  int k=which[i];
  if (k>=0&&k<numberColumns)
    tightenBounds_[k]=1;
}
9727}
9728// Create C++ lines to get to current state
9729std::string
9730CglProbing::generateCpp( FILE * fp) 
9731{
CglProbing other;
fprintf(fp,"0#include \"CglProbing.hpp\"\n");
fprintf(fp,"3  CglProbing probing;\n");
if (getMode()!=other.getMode())
  fprintf(fp,"3  probing.setMode(%d);\n",getMode());
else
  fprintf(fp,"4  probing.setMode(%d);\n",getMode());
if (getMaxPass()!=other.getMaxPass())
  fprintf(fp,"3  probing.setMaxPass(%d);\n",getMaxPass());
else
  fprintf(fp,"4  probing.setMaxPass(%d);\n",getMaxPass());
if (getLogLevel()!=other.getLogLevel())
  fprintf(fp,"3  probing.setLogLevel(%d);\n",getLogLevel());
else
  fprintf(fp,"4  probing.setLogLevel(%d);\n",getLogLevel());
if (getMaxProbe()!=other.getMaxProbe())
  fprintf(fp,"3  probing.setMaxProbe(%d);\n",getMaxProbe());
else
  fprintf(fp,"4  probing.setMaxProbe(%d);\n",getMaxProbe());
if (getMaxLook()!=other.getMaxLook())
  fprintf(fp,"3  probing.setMaxLook(%d);\n",getMaxLook());
else
  fprintf(fp,"4  probing.setMaxLook(%d);\n",getMaxLook());
if (getMaxElements()!=other.getMaxElements())
  fprintf(fp,"3  probing.setMaxElements(%d);\n",getMaxElements());
else
  fprintf(fp,"4  probing.setMaxElements(%d);\n",getMaxElements());
if (getMaxPassRoot()!=other.getMaxPassRoot())
  fprintf(fp,"3  probing.setMaxPassRoot(%d);\n",getMaxPassRoot());
else
  fprintf(fp,"4  probing.setMaxPassRoot(%d);\n",getMaxPassRoot());
if (getMaxProbeRoot()!=other.getMaxProbeRoot())
  fprintf(fp,"3  probing.setMaxProbeRoot(%d);\n",getMaxProbeRoot());
else
  fprintf(fp,"4  probing.setMaxProbeRoot(%d);\n",getMaxProbeRoot());
if (getMaxLookRoot()!=other.getMaxLookRoot())
  fprintf(fp,"3  probing.setMaxLookRoot(%d);\n",getMaxLookRoot());
else
  fprintf(fp,"4  probing.setMaxLookRoot(%d);\n",getMaxLookRoot());
if (getMaxElementsRoot()!=other.getMaxElementsRoot())
  fprintf(fp,"3  probing.setMaxElementsRoot(%d);\n",getMaxElementsRoot());
else
  fprintf(fp,"4  probing.setMaxElementsRoot(%d);\n",getMaxElementsRoot());
if (rowCuts()!=other.rowCuts())
  fprintf(fp,"3  probing.setRowCuts(%d);\n",rowCuts());
else
  fprintf(fp,"4  probing.setRowCuts(%d);\n",rowCuts());
if (getUsingObjective()!=other.getUsingObjective())
  fprintf(fp,"3  probing.setUsingObjective(%d);\n",getUsingObjective());
else
  fprintf(fp,"4  probing.setUsingObjective(%d);\n",getUsingObjective());
if (getAggressiveness()!=other.getAggressiveness())
  fprintf(fp,"3  probing.setAggressiveness(%d);\n",getAggressiveness());
else
  fprintf(fp,"4  probing.setAggressiveness(%d);\n",getAggressiveness());
return "probing";
9788}
9789//-------------------------------------------------------------
9790void
9791CglImplication::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
		const CglTreeInfo info)
9793{
if (probingInfo_) {
  //int n1=cs.sizeRowCuts();
  probingInfo_->generateCuts(si,cs,info);
  //int n2=cs.sizeRowCuts();
  //if (n2>n1)
  //printf("added %d cuts\n",n2-n1);
}
9801}

9803//-------------------------------------------------------------------
9804// Default Constructor 
9805//-------------------------------------------------------------------
9806CglImplication::CglImplication ()

9808CglCutGenerator(),
9809probingInfo_(NULL__null)
9810{
// nothing to do here
9812}
9813//-------------------------------------------------------------------
9814// Constructor with info
9815//-------------------------------------------------------------------
9816CglImplication::CglImplication (CglTreeProbingInfo * info)

9818CglCutGenerator(),
9819probingInfo_(info)
9820{
// nothing to do here
9822}
9823//-------------------------------------------------------------------
9824// Copy constructor 
9825//-------------------------------------------------------------------
9826CglImplication::CglImplication (
                const CglImplication & source)

9829CglCutGenerator(source),
9830probingInfo_(source.probingInfo_)
9831{  
// Nothing to do here
9833}


9836//-------------------------------------------------------------------
9837// Clone
9838//-------------------------------------------------------------------
9839CglCutGenerator *
9840CglImplication::clone() const
9841{
return new CglImplication(*this);
9843}

9845//-------------------------------------------------------------------
9846// Destructor 
9847//-------------------------------------------------------------------
9848CglImplication::~CglImplication ()
9849{
// Nothing to do here
9851}

9853//----------------------------------------------------------------
9854// Assignment operator 
9855//-------------------------------------------------------------------
9856CglImplication &
9857CglImplication::operator=(
                 const CglImplication& rhs)
9859{
if (this != &rhs) {
  CglCutGenerator::operator=(rhs);
  probingInfo_=rhs.probingInfo_;
}
return *this;
9865}
9866// Create C++ lines to get to current state
9867std::string
9868CglImplication::generateCpp( FILE * fp) 
9869{
CglImplication other;
fprintf(fp,"0#include \"CglImplication.hpp\"\n");
fprintf(fp,"3  CglImplication implication;\n");
return "implication";
9874}

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/stl_algo.h

→

1// Algorithm implementation -*- C++ -*-

3// Copyright (C) 2001-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_algo.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{algorithm}
*/

56#ifndef _STL_ALGO_H1
57#define _STL_ALGO_H1 1

59#include <cstdlib>	     // for rand
60#include <bits/algorithmfwd.h>
61#include <bits/stl_heap.h>
62#include <bits/stl_tempbuf.h>  // for _Temporary_buffer
63#include <bits/predefined_ops.h>

65#if __cplusplus201402L >= 201103L
66#include <bits/uniform_int_dist.h>
67#endif

69// See concept_check.h for the __glibcxx_*_requires macros.

71namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
72{
73_GLIBCXX_BEGIN_NAMESPACE_VERSION

/// Swaps the median value of *__a, *__b and *__c under __comp to *__result
template<typename _Iterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
	   _Iterator __c, _Compare __comp)
  {
    if (__comp(__a, __b))
{
 if (__comp(__b, __c))
   std::iter_swap(__result, __b);
 else if (__comp(__a, __c))
   std::iter_swap(__result, __c);
 else
   std::iter_swap(__result, __a);
}
    else if (__comp(__a, __c))
std::iter_swap(__result, __a);
    else if (__comp(__b, __c))
std::iter_swap(__result, __c);
    else
std::iter_swap(__result, __b);
  }

/// Provided for stable_partition to use.
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  __find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
  {
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__negate(__pred),
	    std::__iterator_category(__first));
  }

/// Like find_if_not(), but uses and updates a count of the
/// remaining range length instead of comparing against an end
/// iterator.
template<typename _InputIterator, typename _Predicate, typename _Distance>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
  {
    for (; __len; --__len,  (void) ++__first)
if (!__pred(__first))
 break;
    return __first;
  }

// set_difference
// set_intersection
// set_symmetric_difference
// set_union
// for_each
// find
// find_if
// find_first_of
// adjacent_find
// count
// count_if
// search

template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate  __predicate)
  {
    // Test for empty ranges
    if (__first1 == __last1 || __first2 == __last2)
return __first1;

    // Test for a pattern of length 1.
    _ForwardIterator2 __p1(__first2);
    if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

    // General case.
    _ForwardIterator1 __current = __first1;

    for (;;)
{
 __first1 =
   std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

 if (__first1 == __last1)
   return __last1;

 _ForwardIterator2 __p = __p1;
 __current = __first1;
 if (++__current == __last1)
   return __last1;

 while (__predicate(__current, __p))
   {
     if (++__p == __last2)
return __first1;
     if (++__current == __last1)
return __last1;
   }
 ++__first1;
}
    return __first1;
  }

// search_n

/**
 *  This is an helper function for search_n overloaded for forward iterators.
*/
template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::forward_iterator_tag)
  {
    __first = std::__find_if(__first, __last, __unary_pred);
    while (__first != __last)
{
 typename iterator_traits<_ForwardIterator>::difference_type
   __n = __count;
 _ForwardIterator __i = __first;
 ++__i;
 while (__i != __last && __n != 1 && __unary_pred(__i))
   {
     ++__i;
     --__n;
   }
 if (__n == 1)
   return __first;
 if (__i == __last)
   return __last;
 __first = std::__find_if(++__i, __last, __unary_pred);
}
    return __last;
  }

/**
 *  This is an helper function for search_n overloaded for random access
 *  iterators.
*/
template<typename _RandomAccessIter, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIter
  __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::random_access_iterator_tag)
  {
    typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
_DistanceType;

    _DistanceType __tailSize = __last - __first;
    _DistanceType __remainder = __count;

    while (__remainder <= __tailSize) // the main loop...
{
 __first += __remainder;
 __tailSize -= __remainder;
 // __first here is always pointing to one past the last element of
 // next possible match.
 _RandomAccessIter __backTrack = __first; 
 while (__unary_pred(--__backTrack))
   {
     if (--__remainder == 0)
return (__first - __count); // Success
   }
 __remainder = __count + 1 - (__first - __backTrack);
}
    return __last; // Failure
  }

template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count,
      _UnaryPredicate __unary_pred)
  {
    if (__count <= 0)
return __first;

    if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);

    return std::__search_n_aux(__first, __last, __count, __unary_pred,
		 std::__iterator_category(__first));
  }

// find_end for forward iterators.
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      forward_iterator_tag, forward_iterator_tag,
      _BinaryPredicate __comp)
  {
    if (__first2 == __last2)
return __last1;

    _ForwardIterator1 __result = __last1;
    while (1)
{
 _ForwardIterator1 __new_result
   = std::__search(__first1, __last1, __first2, __last2, __comp);
 if (__new_result == __last1)
   return __result;
 else
   {
     __result = __new_result;
     __first1 = __new_result;
     ++__first1;
   }
}
  }

// find_end for bidirectional iterators (much faster).
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator1
  __find_end(_BidirectionalIterator1 __first1,
      _BidirectionalIterator1 __last1,
      _BidirectionalIterator2 __first2,
      _BidirectionalIterator2 __last2,
      bidirectional_iterator_tag, bidirectional_iterator_tag,
      _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator1>)
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator2>)

    typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
    typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

    _RevIterator1 __rlast1(__first1);
    _RevIterator2 __rlast2(__first2);
    _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
			      _RevIterator2(__last2), __rlast2,
			      __comp);

    if (__rresult == __rlast1)
return __last1;
    else
{
 _BidirectionalIterator1 __result = __rresult.base();
 std::advance(__result, -std::distance(__first2, __last2));
 return __result;
}
  }

/**
 *  @brief  Find last matching subsequence in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @return   The last iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) ==
 *  @p *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the __first
 *  element of the sub-sequence, or @p __last1 if the sub-sequence
 *  is not found.  The sub-sequence will be the last such
 *  subsequence contained in [__first1,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Find last matching subsequence in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @param  __comp    The predicate to use.
 *  @return The last iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c
 *  predicate(*(i+N), @p (__first2+N)) is true for each @c N in the
 *  range @p [0,__last2-__first2), or @p __last1 if no such iterator
 *  exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) using comp as a predicate and returns an
 *  iterator to the first element of the sub-sequence, or @p __last1
 *  if the sub-sequence is not found.  The sub-sequence will be the
 *  last such subsequence contained in [__first,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

436#if __cplusplus201402L >= 201103L
/**
 *  @brief  Checks that a predicate is true for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is true for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == std::find_if_not(__first, __last, __pred); }

/**
 *  @brief  Checks that a predicate is false for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is false for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == _GLIBCXX_STD_Astd::find_if(__first, __last, __pred); }

/**
 *  @brief  Checks that a predicate is false for at least an element
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if an element exists in the range @p
 *  [__first,__last) such that @p __pred is true, and false
 *  otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return !std::none_of(__first, __last, __pred); }

/**
 *  @brief  Find the first element in a sequence for which a
 *          predicate is false.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is false, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if_not(__first, __last,
		__gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Checks whether the sequence is partitioned.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return  True if the range @p [__first,__last) is partioned by @p __pred,
 *  i.e. if all elements that satisfy @p __pred appear before those that
 *  do not.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_partitioned(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    __first = std::find_if_not(__first, __last, __pred);
    if (__first == __last)
return true;
    ++__first;
    return std::none_of(__first, __last, __pred);
  }

/**
 *  @brief  Find the partition point of a partitioned range.
 *  @ingroup mutating_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __pred    A predicate.
 *  @return  An iterator @p mid such that @p all_of(__first, mid, __pred)
 *           and @p none_of(mid, __last, __pred) are both true.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  partition_point(_ForwardIterator __first, _ForwardIterator __last,
    _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_ForwardIterator>::value_type>)

    // A specific debug-mode test will be necessary...
    __glibcxx_requires_valid_range(__first, __last);

    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__pred(*__middle))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else
   __len = __half;
}
    return __first;
  }
584#endif

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
  {
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Copy a sequence, removing elements of a given value.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __value   The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) not equal
 *  to @p __value to the range beginning at @p __result.
 *  remove_copy() is stable, so the relative order of elements that
 *  are copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Copy a sequence, removing elements for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns false to the range beginning at @p __result.
 *
 *  remove_copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
		   __gnu_cxx::__ops::__pred_iter(__pred));
  }

668#if __cplusplus201402L >= 201103L
/**
 *  @brief Copy the elements of a sequence for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p __result.
 *
 *  copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    if (__n > 0)
{
 while (true)
   {
     *__result = *__first;
     ++__result;
     if (--__n > 0)
++__first;
     else
break;
   }
}
    return __result;
  }

template<typename _CharT, typename _Size>
  __enable_if_t<__is_char<_CharT>::__value, _CharT*>
  __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
      _Size, _CharT*);

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n(_InputIterator __first, _Size __n,
    _OutputIterator __result, input_iterator_tag)
  {
    return std::__niter_wrap(__result,
	       __copy_n_a(__first, __n,
			  std::__niter_base(__result)));
  }

template<typename _RandomAccessIterator, typename _Size,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  __copy_n(_RandomAccessIterator __first, _Size __n,
    _OutputIterator __result, random_access_iterator_tag)
  { return std::copy(__first, __first + __n, __result); }

/**
 *  @brief Copies the range [first,first+n) into [result,result+n).
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      The number of elements to copy.
 *  @param  __result An output iterator.
 *  @return  result+n.
 *
 *  This inline function will boil down to a call to @c memmove whenever
 *  possible.  Failing that, if random access iterators are passed, then the
 *  loop count will be known (and therefore a candidate for compiler
 *  optimizations such as unrolling).
*/
template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_can_increment(__first, __n);
    __glibcxx_requires_can_increment(__result, __n);

    return std::__copy_n(__first, __n, __result,
	   std::__iterator_category(__first));
  }

/**
 *  @brief Copy the elements of a sequence to separate output sequences
 *         depending on the truth value of a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __out_true   An output iterator.
 *  @param  __out_false  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   A pair designating the ends of the resulting sequences.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p out_true
 *  and each element for which @p __pred returns false to @p __out_false.
*/
template<typename _InputIterator, typename _OutputIterator1,
  typename _OutputIterator2, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  pair<_OutputIterator1, _OutputIterator2>
  partition_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator1 __out_true, _OutputIterator2 __out_false,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    
    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__out_true = *__first;
   ++__out_true;
 }
else
 {
   *__out_false = *__first;
   ++__out_false;
 }

    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
  }
828#endif // C++11

template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
  {
    __first = std::__find_if(__first, __last, __pred);
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    ++__first;
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = _GLIBCXX_MOVE(*__first)std::move(*__first);
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Remove elements from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements equal to @p __value are removed from the range
 *  @p [__first,__last).
 *
 *  remove() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Remove elements from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __pred   A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements for which @p __pred returns true are removed from the range
 *  @p [__first,__last).
 *
 *  remove_if() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove_if(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
	      __gnu_cxx::__ops::__pred_iter(__pred));
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    if (__first == __last)
return __last;
    _ForwardIterator __next = __first;
    while (++__next != __last)
{
 if (__binary_pred(__first, __next))
   return __first;
 __first = __next;
}
    return __last;
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    // Skip the beginning, if already unique.
    __first = std::__adjacent_find(__first, __last, __binary_pred);
    if (__first == __last)
return __last;

    // Do the real copy work.
    _ForwardIterator __dest = __first;
    ++__first;
    while (++__first != __last)
if (!__binary_pred(__dest, __first))
 *++__dest = _GLIBCXX_MOVE(*__first)std::move(*__first);
    return ++__dest;
  }

/**
 *  @brief Remove consecutive duplicate values from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values that compare equal.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
     typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Remove consecutive values from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values for which @p __binary_pred returns true.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIterator>::value_type,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for forward iterators and output iterator as result.
*/
template<typename _ForwardIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  forward_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_ForwardIterator>::value_type>)

    _ForwardIterator __next = __first;
    *__result = *__first;
    while (++__next != __last)
if (!__binary_pred(__first, __next))
 {
   __first = __next;
   *++__result = *__first;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and output iterator as result.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_InputIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)

    typename iterator_traits<_InputIterator>::value_type __value = *__first;
    __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
__rebound_pred
= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
    *__result = __value;
    while (++__first != __last)
if (!__rebound_pred(__first, __value))
 {
   __value = *__first;
   *++__result = __value;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and forward iterator as result.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _ForwardIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, forward_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)
    *__result = *__first;
    while (++__first != __last)
if (!__binary_pred(__result, __first))
 *++__result = *__first;
    return ++__result;
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for bidirectional iterators.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    while (true)
if (__first == __last || __first == --__last)
 return;
else
 {
   std::iter_swap(__first, __last);
   ++__first;
 }
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for random access iterators.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
     random_access_iterator_tag)
  {
    if (__first == __last)
return;
    --__last;
    while (__first < __last)
{
 std::iter_swap(__first, __last);
 ++__first;
 --__last;
}
  }

/**
 *  @brief Reverse a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A bidirectional iterator.
 *  @param  __last   A bidirectional iterator.
 *  @return   reverse() returns no value.
 *
 *  Reverses the order of the elements in the range @p [__first,__last),
 *  so that the first element becomes the last etc.
 *  For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse()
 *  swaps @p *(__first+i) and @p *(__last-(i+1))
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    std::__reverse(__first, __last, std::__iterator_category(__first));
  }

/**
 *  @brief Copy a sequence, reversing its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A bidirectional iterator.
 *  @param  __last    A bidirectional iterator.
 *  @param  __result  An output iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements in the range @p [__first,__last) to the
 *  range @p [__result,__result+(__last-__first)) such that the
 *  order of the elements is reversed.  For every @c i such that @p
 *  0<=i<=(__last-__first), @p reverse_copy() performs the
 *  assignment @p *(__result+(__last-__first)-1-i) = *(__first+i).
 *  The ranges @p [__first,__last) and @p
 *  [__result,__result+(__last-__first)) must not overlap.
*/
template<typename _BidirectionalIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    while (__first != __last)
{
 --__last;
 *__result = *__last;
 ++__result;
}
    return __result;
  }

/**
 *  This is a helper function for the rotate algorithm specialized on RAIs.
 *  It returns the greatest common divisor of two integer values.
*/
template<typename _EuclideanRingElement>
  _GLIBCXX20_CONSTEXPR
  _EuclideanRingElement
  __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
  {
    while (__n != 0)
{
 _EuclideanRingElement __t = __m % __n;
 __m = __n;
 __n = __t;
}
    return __m;
  }

inline namespace _V2
{

/// This is a helper function for the rotate algorithm.
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __rotate(_ForwardIterator __first,
    _ForwardIterator __middle,
    _ForwardIterator __last,
    forward_iterator_tag)
  {
    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    _ForwardIterator __first2 = __middle;
    do
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
}
    while (__first2 != __last);

    _ForwardIterator __ret = __first;

    __first2 = __middle;

    while (__first2 != __last)
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
 else if (__first2 == __last)
   __first2 = __middle;
}
    return __ret;
  }

 /// This is a helper function for the rotate algorithm.
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __rotate(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    std::__reverse(__first,  __middle, bidirectional_iterator_tag());
    std::__reverse(__middle, __last,   bidirectional_iterator_tag());

    while (__first != __middle && __middle != __last)
{
 std::iter_swap(__first, --__last);
 ++__first;
}

    if (__first == __middle)
{
 std::__reverse(__middle, __last,   bidirectional_iterator_tag());
 return __last;
}
    else
{
 std::__reverse(__first,  __middle, bidirectional_iterator_tag());
 return __first;
}
  }

/// This is a helper function for the rotate algorithm.
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __rotate(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last,
    random_access_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

    _Distance __n = __last   - __first;
    _Distance __k = __middle - __first;

    if (__k == __n - __k)
{
 std::swap_ranges(__first, __middle, __middle);
 return __middle;
}

    _RandomAccessIterator __p = __first;
    _RandomAccessIterator __ret = __first + (__last - __middle);

    for (;;)
{
 if (__k < __n - __k)
   {
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*__p)std::move(*__p);
  _GLIBCXX_MOVE3(__p + 1, __p + __n, __p)std::move(__p + 1, __p + __n, __p);
  *(__p + __n - 1) = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  std::iter_swap(__p, __q);
  ++__p;
  ++__q;
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
     __k = __n - __k;
   }
 else
   {
     __k = __n - __k;
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1))std::move(*(__p + __n - 1));
  _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n)std::move_backward(__p, __p + __n - 1, __p + __n);
  *__p = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __n;
     __p = __q - __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  --__p;
  --__q;
  std::iter_swap(__p, __q);
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
   }
}
  }

 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // DR 488. rotate throws away useful information
/**
 *  @brief Rotate the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  first + (last - middle).
 *
 *  Rotates the elements of the range @p [__first,__last) by 
 *  @p (__middle - __first) positions so that the element at @p __middle
 *  is moved to @p __first, the element at @p __middle+1 is moved to
 *  @p __first+1 and so on for each element in the range
 *  @p [__first,__last).
 *
 *  This effectively swaps the ranges @p [__first,__middle) and
 *  @p [__middle,__last).
 *
 *  Performs
 *   @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  rotate(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::__rotate(__first, __middle, __last,
	   std::__iterator_category(__first));
  }

} // namespace _V2

/**
 *  @brief Copy a sequence, rotating its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements of the range @p [__first,__last) to the
 *  range beginning at @result, rotating the copied elements by 
 *  @p (__middle-__first) positions so that the element at @p __middle
 *  is moved to @p __result, the element at @p __middle+1 is moved
 *  to @p __result+1 and so on for each element in the range @p
 *  [__first,__last).
 *
 *  Performs 
 *  @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::copy(__first, __middle,
       std::copy(__middle, __last, __result));
  }

/// This is a helper function...
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
  {
    if (__first == __last)
return __first;

    while (__pred(*__first))
if (++__first == __last)
 return __first;

    _ForwardIterator __next = __first;

    while (++__next != __last)
if (__pred(*__next))
 {
   std::iter_swap(__first, __next);
   ++__first;
 }

    return __first;
  }

/// This is a helper function...
template<typename _BidirectionalIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
  {
    while (true)
{
 while (true)
   if (__first == __last)
     return __first;
   else if (__pred(*__first))
     ++__first;
   else
     break;
 --__last;
 while (true)
   if (__first == __last)
     return __first;
   else if (!bool(__pred(*__last)))
     --__last;
   else
     break;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

// partition

/// This is a helper function...
/// Requires __first != __last and !__pred(__first)
/// and __len == distance(__first, __last).
///
/// !__pred(__first) allows us to guarantee that we don't
/// move-assign an element onto itself.
template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
  typename _Distance>
  _ForwardIterator
  __stable_partition_adaptive(_ForwardIterator __first,
		_ForwardIterator __last,
		_Predicate __pred, _Distance __len,
		_Pointer __buffer,
		_Distance __buffer_size)
  {
    if (__len == 1)
return __first;

    if (__len <= __buffer_size)
{
 _ForwardIterator __result1 = __first;
 _Pointer __result2 = __buffer;

 // The precondition guarantees that !__pred(__first), so
 // move that element to the buffer before starting the loop.
 // This ensures that we only call __pred once per element.
 *__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
 ++__result2;
 ++__first;
 for (; __first != __last; ++__first)
   if (__pred(__first))
     {
*__result1 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result1;
     }
   else
     {
*__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result2;
     }

 _GLIBCXX_MOVE3(__buffer, __result2, __result1)std::move(__buffer, __result2, __result1);
 return __result1;
}

    _ForwardIterator __middle = __first;
    std::advance(__middle, __len / 2);
    _ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
			 __len / 2, __buffer,
			 __buffer_size);

    // Advance past true-predicate values to satisfy this
    // function's preconditions.
    _Distance __right_len = __len - __len / 2;
    _ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);

    if (__right_len)
__right_split =
 std::__stable_partition_adaptive(__right_split, __last, __pred,
			   __right_len,
			   __buffer, __buffer_size);

    return std::rotate(__left_split, __middle, __right_split);
  }

template<typename _ForwardIterator, typename _Predicate>
  _ForwardIterator
  __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
  {
    __first = std::__find_if_not(__first, __last, __pred);

    if (__first == __last)
return __first;

    typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _Temporary_buffer<_ForwardIterator, _ValueType>
__buf(__first, std::distance(__first, __last));
    return
std::__stable_partition_adaptive(__first, __last, __pred,
			 _DistanceType(__buf.requested_size()),
			 __buf.begin(),
			 _DistanceType(__buf.size()));
  }

/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence, preserving relative ordering.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [first,middle) and false for each @p i
 *  in the range @p [middle,last).
 *
 *  Performs the same function as @p partition() with the additional
 *  guarantee that the relative ordering of elements in each group is
 *  preserved, so any two elements @p x and @p y in the range
 *  @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same
 *  relative ordering after calling @p stable_partition().
*/
template<typename _ForwardIterator, typename _Predicate>
  inline _ForwardIterator
  stable_partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__stable_partition(__first, __last,
		     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/// This is a helper function for the sort routines.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __heap_select(_RandomAccessIterator __first,
  _RandomAccessIterator __middle,
  _RandomAccessIterator __last, _Compare __comp)
  {
    std::__make_heap(__first, __middle, __comp);
    for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(__i, __first))
 std::__pop_heap(__first, __middle, __i, __comp);
  }

// partial_sort

template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first,
	_RandomAccessIterator __result_last,
	_Compare __comp)
  {
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef iterator_traits<_RandomAccessIterator> _RItTraits;
    typedef typename _RItTraits::difference_type _DistanceType;

    if (__result_first == __result_last)
return __result_last;
    _RandomAccessIterator __result_real_last = __result_first;
    while (__first != __last && __result_real_last != __result_last)
{
 *__result_real_last = *__first;
 ++__result_real_last;
 ++__first;
}
    
    std::__make_heap(__result_first, __result_real_last, __comp);
    while (__first != __last)
{
 if (__comp(__first, __result_first))
   std::__adjust_heap(__result_first, _DistanceType(0),
	       _DistanceType(__result_real_last
			     - __result_first),
	       _InputValueType(*__first), __comp);
 ++__first;
}
    std::__sort_heap(__result_first, __result_real_last, __comp);
    return __result_real_last;
  }

/**
 *  @brief Copy the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p __result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  *j<*i is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last)
  {
1737#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1742#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
				     _OutputValueType>)
    __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		      __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Copy the smallest elements of a sequence using a predicate for
 *         comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    Another input iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @param  __comp    A comparison functor.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  @p __comp(*j,*i) is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last,
      _Compare __comp)
  {
1789#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1794#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _InputValueType, _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _OutputValueType, _OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __unguarded_linear_insert(_RandomAccessIterator __last,
	      _Compare __comp)
  {
    typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__last)std::move(*__last);
    _RandomAccessIterator __next = __last;
    --__next;
    while (__comp(__val, __next))
{
 *__last = _GLIBCXX_MOVE(*__next)std::move(*__next);
 __last = __next;
 --__next;
}
    *__last = _GLIBCXX_MOVE(__val)std::move(__val);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __insertion_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
  {
    if (__first59.1
'__first' is not equal to '__last'
1
'__first' is not equal to '__last'
1
'__first' is not equal to '__last'
 == __last) return;
60
←
Taking false branch→

    for (_RandomAccessIterator __i = __first + 1; __i60.1
'__i' is not equal to '__last'
1
'__i' is not equal to '__last'
1
'__i' is not equal to '__last'
 != __last; ++__i)
61
←
Loop condition is true.  Entering loop body→
{
 if (__comp(__i, __first))
62
←
Calling '_Iter_less_iter::operator()'→
   {
     typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__i)std::move(*__i);
     _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1)std::move_backward(__first, __i, __i + 1);
     *__first = _GLIBCXX_MOVE(__val)std::move(__val);
   }
 else
   std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
}
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __unguarded_insertion_sort(_RandomAccessIterator __first,
	       _RandomAccessIterator __last, _Compare __comp)
  {
    for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @doctodo
 *  This controls some aspect of the sort routines.
*/
enum { _S_threshold = 16 };

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __final_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first > int(_S_threshold))
58
←
Taking false branch→
{
 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
			  __comp);
}
    else
std::__insertion_sort(__first, __last, __comp);
59
←
Calling '__insertion_sort<unsigned int *, __gnu_cxx::__ops::_Iter_less_iter>'→
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __unguarded_partition(_RandomAccessIterator __first,
	  _RandomAccessIterator __last,
	  _RandomAccessIterator __pivot, _Compare __comp)
  {
    while (true)
{
 while (__comp(__first, __pivot))
   ++__first;
 --__last;
 while (__comp(__pivot, __last))
   --__last;
 if (!(__first < __last))
   return __first;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  __unguarded_partition_pivot(_RandomAccessIterator __first,
		_RandomAccessIterator __last, _Compare __comp)
  {
    _RandomAccessIterator __mid = __first + (__last - __first) / 2;
    std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
		  __comp);
    return std::__unguarded_partition(__first + 1, __last, __first, __comp);
  }

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
  {
    std::__heap_select(__first, __middle, __last, __comp);
    std::__sort_heap(__first, __middle, __comp);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introsort_loop(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _Size __depth_limit, _Compare __comp)
  {
    while (__last - __first > int(_S_threshold))
{
 if (__depth_limit == 0)
   {
     std::__partial_sort(__first, __last, __last, __comp);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
 __last = __cut;
}
  }

// sort

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    if (__first55.1
'__first' is not equal to '__last'
1
'__first' is not equal to '__last'
1
'__first' is not equal to '__last'
 != __last)
56
←
Taking true branch→
{
 std::__introsort_loop(__first, __last,
		std::__lg(__last - __first) * 2,
		__comp);
 std::__final_insertion_sort(__first, __last, __comp);
57
←
Calling '__final_insertion_sort<unsigned int *, __gnu_cxx::__ops::_Iter_less_iter>'→
}
  }

template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Size __depth_limit,
  _Compare __comp)
  {
    while (__last - __first > 3)
{
 if (__depth_limit == 0)
   {
     std::__heap_select(__first, __nth + 1, __last, __comp);
     // Place the nth largest element in its final position.
     std::iter_swap(__first, __nth);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 if (__cut <= __nth)
   __first = __cut;
 else
   __last = __cut;
}
    std::__insertion_sort(__first, __last, __comp);
  }

// nth_element

// lower_bound moved to stl_algobase.h

/**
 *  @brief Finds the first position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return An iterator pointing to the first element <em>not less
 *           than</em> @p __val, or end() if every element is less
 *           than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);

    return std::__lower_bound(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp));
  }

template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp(__val, __middle))
   __len = __half;
 else
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
}
    return __first;
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Tp,
  typename _CompareItTp, typename _CompareTpIt>
  _GLIBCXX20_CONSTEXPR
  pair<_ForwardIterator, _ForwardIterator>
  __equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val,
  _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp_it_val(__middle, __val))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else if (__comp_val_it(__val, __middle))
   __len = __half;
 else
   {
     _ForwardIterator __left
= std::__lower_bound(__first, __middle, __val, __comp_it_val);
     std::advance(__first, __len);
     _ForwardIterator __right
= std::__upper_bound(++__middle, __first, __val, __comp_val_it);
     return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
   }
}
    return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val),
 *                   upper_bound(__first, __last, __val))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_less_val(),
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val, __comp),
 *                   upper_bound(__first, __last, __val, __comp))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp),
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return True if @p __val (or its equivalent) is in [@p
 *  __first,@p __last ].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_less_val());
    return __i != __last && !(__val < *__i);
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  True if @p __val (or its equivalent) is in @p [__first,__last].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_comp_val(__comp));
    return __i != __last && !bool(__comp(__val, *__i));
  }

// merge

/// This is a helper function for the __merge_adaptive routines.
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  void
  __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
	  _InputIterator2 __first2, _InputIterator2 __last2,
	  _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result)std::move(__first1, __last1, __result);
  }

/// This is a helper function for the __merge_adaptive routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BidirectionalIterator3, typename _Compare>
  void
  __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
		   _BidirectionalIterator1 __last1,
		   _BidirectionalIterator2 __first2,
		   _BidirectionalIterator2 __last2,
		   _BidirectionalIterator3 __result,
		   _Compare __comp)
  {
    if (__first1 == __last1)
{
 _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result)std::move_backward(__first2, __last2, __result);
 return;
}
    else if (__first2 == __last2)
return;

    --__last1;
    --__last2;
    while (true)
{
 if (__comp(__last2, __last1))
   {
     *--__result = _GLIBCXX_MOVE(*__last1)std::move(*__last1);
     if (__first1 == __last1)
{
  _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result)std::move_backward(__first2, ++__last2, __result);
  return;
}
     --__last1;
   }
 else
   {
     *--__result = _GLIBCXX_MOVE(*__last2)std::move(*__last2);
     if (__first2 == __last2)
return;
     --__last2;
   }
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _Distance>
  _BidirectionalIterator1
  __rotate_adaptive(_BidirectionalIterator1 __first,
      _BidirectionalIterator1 __middle,
      _BidirectionalIterator1 __last,
      _Distance __len1, _Distance __len2,
      _BidirectionalIterator2 __buffer,
      _Distance __buffer_size)
  {
    _BidirectionalIterator2 __buffer_end;
    if (__len1 > __len2 && __len2 <= __buffer_size)
{
 if (__len2)
   {
     __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
     _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last)std::move_backward(__first, __middle, __last);
     return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first)std::move(__buffer, __buffer_end, __first);
   }
 else
   return __first;
}
    else if (__len1 <= __buffer_size)
{
 if (__len1)
   {
     __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
     _GLIBCXX_MOVE3(__middle, __last, __first)std::move(__middle, __last, __first);
     return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last)std::move_backward(__buffer, __buffer_end, __last);
   }
 else
   return __last;
}
    else
return std::rotate(__first, __middle, __last);
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance, 
  typename _Pointer, typename _Compare>
  void
  __merge_adaptive(_BidirectionalIterator __first,
     _BidirectionalIterator __middle,
     _BidirectionalIterator __last,
     _Distance __len1, _Distance __len2,
     _Pointer __buffer, _Distance __buffer_size,
     _Compare __comp)
  {
    if (__len1 <= __len2 && __len1 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
 std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
		     __first, __comp);
}
    else if (__len2 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
 std::__move_merge_adaptive_backward(__first, __middle, __buffer,
			      __buffer_end, __last, __comp);
}
    else
{
 _BidirectionalIterator __first_cut = __first;
 _BidirectionalIterator __second_cut = __middle;
 _Distance __len11 = 0;
 _Distance __len22 = 0;
 if (__len1 > __len2)
   {
     __len11 = __len1 / 2;
     std::advance(__first_cut, __len11);
     __second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
		     __gnu_cxx::__ops::__iter_comp_val(__comp));
     __len22 = std::distance(__middle, __second_cut);
   }
 else
   {
     __len22 = __len2 / 2;
     std::advance(__second_cut, __len22);
     __first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
		     __gnu_cxx::__ops::__val_comp_iter(__comp));
     __len11 = std::distance(__first, __first_cut);
   }

 _BidirectionalIterator __new_middle
   = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
		     __len1 - __len11, __len22, __buffer,
		     __buffer_size);
 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
		__len22, __buffer, __buffer_size, __comp);
 std::__merge_adaptive(__new_middle, __second_cut, __last,
		__len1 - __len11,
		__len2 - __len22, __buffer,
		__buffer_size, __comp);
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance,
  typename _Compare>
  void
  __merge_without_buffer(_BidirectionalIterator __first,
	   _BidirectionalIterator __middle,
	   _BidirectionalIterator __last,
	   _Distance __len1, _Distance __len2,
	   _Compare __comp)
  {
    if (__len1 == 0 || __len2 == 0)
return;

    if (__len1 + __len2 == 2)
{
 if (__comp(__middle, __first))
   std::iter_swap(__first, __middle);
 return;
}

    _BidirectionalIterator __first_cut = __first;
    _BidirectionalIterator __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2)
{
 __len11 = __len1 / 2;
 std::advance(__first_cut, __len11);
 __second_cut
   = std::__lower_bound(__middle, __last, *__first_cut,
		 __gnu_cxx::__ops::__iter_comp_val(__comp));
 __len22 = std::distance(__middle, __second_cut);
}
    else
{
 __len22 = __len2 / 2;
 std::advance(__second_cut, __len22);
 __first_cut
   = std::__upper_bound(__first, __middle, *__second_cut,
		 __gnu_cxx::__ops::__val_comp_iter(__comp));
 __len11 = std::distance(__first, __first_cut);
}

    _BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
    std::__merge_without_buffer(__first, __first_cut, __new_middle,
		  __len11, __len22, __comp);
    std::__merge_without_buffer(__new_middle, __second_cut, __last,
		  __len1 - __len11, __len2 - __len22, __comp);
  }

template<typename _BidirectionalIterator, typename _Compare>
  void
  __inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
  {
    typedef typename iterator_traits<_BidirectionalIterator>::value_type
 _ValueType;
    typedef typename iterator_traits<_BidirectionalIterator>::difference_type
 _DistanceType;

    if (__first == __middle || __middle == __last)
return;

    const _DistanceType __len1 = std::distance(__first, __middle);
    const _DistanceType __len2 = std::distance(__middle, __last);

    typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, __len1 + __len2);

    if (__buf.begin() == 0)
std::__merge_without_buffer
 (__first, __middle, __last, __len1, __len2, __comp);
    else
std::__merge_adaptive
 (__first, __middle, __last, __len1, __len2, __buf.begin(),
  _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [__middle,__last), and puts the result in [__first,__last).  The
 *  output will be sorted.  The sort is @e stable, that is, for
 *  equivalent elements in the two ranges, elements from the first
 *  range will always come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
*/
template<typename _BidirectionalIterator>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted(__first, __middle);
    __glibcxx_requires_sorted(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [middle,last), and puts the result in [__first,__last).  The output will
 *  be sorted.  The sort is @e stable, that is, for equivalent
 *  elements in the two ranges, elements from the first range will always
 *  come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _BidirectionalIterator, typename _Compare>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last,
  _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted_pred(__first, __middle, __comp);
    __glibcxx_requires_sorted_pred(__middle, __last, __comp);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }


/// This is a helper function for the __merge_sort_loop routines.
template<typename _InputIterator, typename _OutputIterator,
  typename _Compare>
  _OutputIterator
  __move_merge(_InputIterator __first1, _InputIterator __last1,
 _InputIterator __first2, _InputIterator __last2,
 _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    return _GLIBCXX_MOVE3(__first2, __last2,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
	    _GLIBCXX_MOVE3(__first1, __last1,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
			   __result))std::move(__first2, __last2, std::move(__first1, __last1, __result
));
  }

template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
  typename _Distance, typename _Compare>
  void
  __merge_sort_loop(_RandomAccessIterator1 __first,
      _RandomAccessIterator1 __last,
      _RandomAccessIterator2 __result, _Distance __step_size,
      _Compare __comp)
  {
    const _Distance __two_step = 2 * __step_size;

    while (__last - __first >= __two_step)
{
 __result = std::__move_merge(__first, __first + __step_size,
		       __first + __step_size,
		       __first + __two_step,
		       __result, __comp);
 __first += __two_step;
}
    __step_size = std::min(_Distance(__last - __first), __step_size);

    std::__move_merge(__first, __first + __step_size,
	__first + __step_size, __last, __result, __comp);
  }

template<typename _RandomAccessIterator, typename _Distance,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __chunk_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Distance __chunk_size, _Compare __comp)
  {
    while (__last - __first >= __chunk_size)
{
 std::__insertion_sort(__first, __first + __chunk_size, __comp);
 __first += __chunk_size;
}
    std::__insertion_sort(__first, __last, __comp);
  }

enum { _S_chunk_size = 7 };

template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
  void
  __merge_sort_with_buffer(_RandomAccessIterator __first,
	     _RandomAccessIterator __last,
	     _Pointer __buffer, _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;

    const _Distance __len = __last - __first;
    const _Pointer __buffer_last = __buffer + __len;

    _Distance __step_size = _S_chunk_size;
    std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

    while (__step_size < __len)
{
 std::__merge_sort_loop(__first, __last, __buffer,
		 __step_size, __comp);
 __step_size *= 2;
 std::__merge_sort_loop(__buffer, __buffer_last, __first,
		 __step_size, __comp);
 __step_size *= 2;
}
  }

template<typename _RandomAccessIterator, typename _Pointer,
  typename _Distance, typename _Compare>
  void
  __stable_sort_adaptive(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Pointer __buffer, _Distance __buffer_size,
	   _Compare __comp)
  {
    const _Distance __len = (__last - __first + 1) / 2;
    const _RandomAccessIterator __middle = __first + __len;
    if (__len > __buffer_size)
{
 std::__stable_sort_adaptive(__first, __middle, __buffer,
		      __buffer_size, __comp);
 std::__stable_sort_adaptive(__middle, __last, __buffer,
		      __buffer_size, __comp);
}
    else
{
 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
    std::__merge_adaptive(__first, __middle, __last,
	    _Distance(__middle - __first),
	    _Distance(__last - __middle),
	    __buffer, __buffer_size,
	    __comp);
  }

/// This is a helper function for the stable sorting routines.
template<typename _RandomAccessIterator, typename _Compare>
  void
  __inplace_stable_sort(_RandomAccessIterator __first,
	  _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first < 15)
{
 std::__insertion_sort(__first, __last, __comp);
 return;
}
    _RandomAccessIterator __middle = __first + (__last - __first) / 2;
    std::__inplace_stable_sort(__first, __middle, __comp);
    std::__inplace_stable_sort(__middle, __last, __comp);
    std::__merge_without_buffer(__first, __middle, __last,
		  __middle - __first,
		  __last - __middle,
		  __comp);
  }

// stable_sort

// Set algorithms: includes, set_union, set_intersection, set_difference,
// set_symmetric_difference.  All of these algorithms have the precondition
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted.

template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first2, __first1))
 return false;
else if (__comp(__first1, __first2))
 ++__first1;
else
 {
   ++__first1;
   ++__first2;
 }

    return __first2 == __last2;
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range.
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @return  True if each element in [__first2,__last2) is contained in order
 *  within [__first1,__last1).  False otherwise.
 *  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1).
 *  The iterators over each range only move forward, so this is a
 *  linear algorithm.  If an element in [__first2,__last2) is not
 *  found before the search iterator reaches @p __last2, false is
 *  returned.
*/
template<typename _InputIterator1, typename _InputIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range
 *  using comparison.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @param  __comp    Comparison function to use.
 *  @return True if each element in [__first2,__last2) is contained
 *  in order within [__first1,__last1) according to comp.  False
 *  otherwise.  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1),
 *  using comp to decide.  The iterators over each range only move
 *  forward, so this is a linear algorithm.  If an element in
 *  [__first2,__last2) is not found before the search iterator
 *  reaches @p __last2, false is returned.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// nth_element
// merge
// set_difference
// set_intersection
// set_union
// stable_sort
// set_symmetric_difference
// min_element
// max_element

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__i, __ii))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(__i, --__j))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the next one of this set.
 *  Returns true if there are more sequences to generate.  If the sequence
 *  is the largest of the set, the smallest is generated and false returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the next one of this set.  Returns true if there are more
 *  sequences to generate.  If the sequence is the largest of the set, the
 *  smallest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__ii, __i))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(--__j, __i))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the previous one of this
 *  set.  Returns true if there are more sequences to generate.  If the
 *  sequence is the smallest of the set, the largest is generated and false
 *  returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__prev_permutation(__first, __last,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the previous one of this set.  Returns true if there are
 *  more sequences to generate.  If the sequence is the smallest of the set,
 *  the largest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__prev_permutation(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// replace
// replace_if

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
  {
    for (; __first != __last; ++__first, (void)++__result)
if (__pred(__first))
 *__result = __new_value;
else
 *__result = *__first;
    return __result;
  }

/**
 *  @brief Copy a sequence, replacing each element of one value with another
 *         value.
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p result+(last-first).
 *
 *  Copies each element in the input range @p [__first,__last) to the
 *  output range @p [__result,__result+(__last-__first)) replacing elements
 *  equal to @p __old_value with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy(_InputIterator __first, _InputIterator __last,
 _OutputIterator __result,
 const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
	__gnu_cxx::__ops::__iter_equals_val(__old_value),
			      __new_value);
  }

/**
 *  @brief Copy a sequence, replacing each value for which a predicate
 *         returns true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p __result+(__last-__first).
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  @p [__result,__result+(__last-__first)) replacing elements for which
 *  @p __pred returns true with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy_if(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
		__gnu_cxx::__ops::__pred_iter(__pred),
			      __new_value);
  }

3212#if __cplusplus201402L >= 201103L
/**
 *  @brief  Determines whether the elements of a sequence are sorted.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last)
  { return std::is_sorted_until(__first, __last) == __last; }

/**
 *  @brief  Determines whether the elements of a sequence are sorted
 *          according to a comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  { return std::is_sorted_until(__first, __last, __comp) == __last; }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
  {
    if (__first == __last)
return __last;

    _ForwardIterator __next = __first;
    for (++__next; __next != __last; __first = __next, (void)++__next)
if (__comp(__next, __first))
 return __next;
    return __next;
  }

/**
 *  @brief  Determines the end of a sorted sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Determines the end of a sorted sequence using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b)
  {
    // concept requirements
    __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)

    return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
       : pair<const _Tp&, const _Tp&>(__a, __b);
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @param  __comp  A @link comparison_functors comparison functor @endlink.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
  {
    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
	      : pair<const _Tp&, const _Tp&>(__a, __b);
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  pair<_ForwardIterator, _ForwardIterator>
  __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  {
    _ForwardIterator __next = __first;
    if (__first == __last
 || ++__next == __last)
return std::make_pair(__first, __first);

    _ForwardIterator __min{}, __max{};
    if (__comp(__next, __first))
{
 __min = __next;
 __max = __first;
}
    else
{
 __min = __first;
 __max = __next;
}

    __first = __next;
    ++__first;

    while (__first != __last)
{
 __next = __first;
 if (++__next == __last)
   {
     if (__comp(__first, __min))
__min = __first;
     else if (!__comp(__first, __max))
__max = __first;
     break;
   }

 if (__comp(__next, __first))
   {
     if (__comp(__next, __min))
__min = __next;
     if (!__comp(__first, __max))
__max = __first;
   }
 else
   {
     if (__comp(__first, __min))
__min = __first;
     if (!__comp(__next, __max))
__max = __next;
   }

 __first = __next;
 ++__first;
}

    return std::make_pair(__min, __max);
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last,
   _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// N2722 + DR 915.
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l)
  { return *std::min_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::min_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l)
  { return *std::max_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::max_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end());
    return std::make_pair(*__p.first, *__p.second);
  }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l, _Compare __comp)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end(), __comp);
    return std::make_pair(*__p.first, *__p.second);
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in
 *          the range [__first2, __first2 + (__last1 - __first1)),
 *          beginning with ForwardIterator2 begin, such that
 *          equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _BinaryPredicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);

    return std::__is_permutation(__first1, __last1, __first2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3542#if __cplusplus201402L > 201103L
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  bool
  __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
  {
    using _Cat1
= typename iterator_traits<_ForwardIterator1>::iterator_category;
    using _Cat2
= typename iterator_traits<_ForwardIterator2>::iterator_category;
    using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
    using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
    constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
    if (__ra_iters)
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 != __d2)
   return false;
}

    // Efficiently compare identical prefixes:  O(N) if sequences
    // have the same elements in the same order.
    for (; __first1 != __last1 && __first2 != __last2;
 ++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
 break;

    if (__ra_iters)
{
 if (__first1 == __last1)
   return true;
}
    else
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 == 0 && __d2 == 0)
   return true;
 if (__d1 != __d2)
   return false;
}

    for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
 if (__scan != std::__find_if(__first1, __scan,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
   continue; // We've seen this one before.

 auto __matches = std::__count_if(__first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
 if (0 == __matches
     || std::__count_if(__scan, __last1,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
     != __matches)
   return false;
}
    return true;
  }

/**
 *  @brief  Checks whether a permutaion of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, begin) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return
std::__is_permutation(__first1, __last1, __first2, __last2,
	      __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
   _BinaryPredicate __pred)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__is_permutation(__first1, __last1, __first2, __last2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3661#if __cplusplus201402L > 201402L

3663#define __cpp_lib_clamp 201603

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val  A value of arbitrary type.
 *  @param  __lo   A lower limit of arbitrary type.
 *  @param  __hi   An upper limit of arbitrary type.
 *  @return max(__val, __lo) if __val < __hi or min(__val, __hi) otherwise.
 */
template<typename _Tp>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
  {
    __glibcxx_assert(!(__hi < __lo));
    return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
  }

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val   A value of arbitrary type.
 *  @param  __lo    A lower limit of arbitrary type.
 *  @param  __hi    An upper limit of arbitrary type.
 *  @param  __comp  A comparison functor.
 *  @return max(__val, __lo, __comp) if __comp(__val, __hi)
 *	      or min(__val, __hi, __comp) otherwise.
 */
template<typename _Tp, typename _Compare>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
  {
    __glibcxx_assert(!__comp(__hi, __lo));
    return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
  }
3698#endif // C++17
3699#endif // C++14

3701#ifdef _GLIBCXX_USE_C99_STDINT_TR11
/**
 *  @brief Generate two uniformly distributed integers using a
 *         single distribution invocation.
 *  @param  __b0    The upper bound for the first integer.
 *  @param  __b1    The upper bound for the second integer.
 *  @param  __g     A UniformRandomBitGenerator.
 *  @return  A pair (i, j) with i and j uniformly distributed
 *           over [0, __b0) and [0, __b1), respectively.
 *
 *  Requires: __b0 * __b1 <= __g.max() - __g.min().
 *
 *  Using uniform_int_distribution with a range that is very
 *  small relative to the range of the generator ends up wasting
 *  potentially expensively generated randomness, since
 *  uniform_int_distribution does not store leftover randomness
 *  between invocations.
 *
 *  If we know we want two integers in ranges that are sufficiently
 *  small, we can compose the ranges, use a single distribution
 *  invocation, and significantly reduce the waste.
*/
template<typename _IntType, typename _UniformRandomBitGenerator>
  pair<_IntType, _IntType>
  __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
	   _UniformRandomBitGenerator&& __g)
  {
    _IntType __x
= uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
    return std::make_pair(__x / __b1, __x % __b1);
  }

/**
 *  @brief Shuffle the elements of a sequence using a uniform random
 *         number generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __g       A UniformRandomNumberGenerator (26.5.1.3).
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __g to
 *  provide random numbers.
*/
template<typename _RandomAccessIterator,
  typename _UniformRandomNumberGenerator>
  void
  shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
   _UniformRandomNumberGenerator&& __g)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
    typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
    typedef typename __distr_type::param_type __p_type;

    typedef typename remove_reference<_UniformRandomNumberGenerator>::type
_Gen;
    typedef typename common_type<typename _Gen::result_type, __ud_type>::type
__uc_type;

    const __uc_type __urngrange = __g.max() - __g.min();
    const __uc_type __urange = __uc_type(__last - __first);

    if (__urngrange / __urange >= __urange)
      // I.e. (__urngrange >= __urange * __urange) but without wrap issues.
    {
_RandomAccessIterator __i = __first + 1;

// Since we know the range isn't empty, an even number of elements
// means an uneven number of elements /to swap/, in which case we
// do the first one up front:

if ((__urange % 2) == 0)
{
 __distr_type __d{0, 1};
 std::iter_swap(__i++, __first + __d(__g));
}

// Now we know that __last - __i is even, so we do the rest in pairs,
// using a single distribution invocation to produce swap positions
// for two successive elements at a time:

while (__i != __last)
{
 const __uc_type __swap_range = __uc_type(__i - __first) + 1;

 const pair<__uc_type, __uc_type> __pospos =
   __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);

 std::iter_swap(__i++, __first + __pospos.first);
 std::iter_swap(__i++, __first + __pospos.second);
}

return;
    }

    __distr_type __d;

    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
  }
3812#endif

3814#endif // C++11

3816_GLIBCXX_BEGIN_NAMESPACE_ALGO

/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __f      A unary function object.
 *  @return   @p __f
 *
 *  Applies the function object @p __f to each element in the range
 *  @p [first,last).  @p __f must not modify the order of the sequence.
 *  If @p __f has a return value it is ignored.
*/
template<typename _InputIterator, typename _Function>
  _GLIBCXX20_CONSTEXPR
  _Function
  for_each(_InputIterator __first, _InputIterator __last, _Function __f)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    for (; __first != __last; ++__first)
__f(*__first);
    return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
  }

3843#if __cplusplus201402L >= 201703L
/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      A value convertible to an integer.
 *  @param  __f      A unary function object.
 *  @return   `__first+__n`
 *
 *  Applies the function object `__f` to each element in the range
 *  `[first, first+n)`.  `__f` must not modify the order of the sequence.
 *  If `__f` has a return value it is ignored.
*/
template<typename _InputIterator, typename _Size, typename _Function>
  _InputIterator
  for_each_n(_InputIterator __first, _Size __n, _Function __f)
  {
    auto __n2 = std::__size_to_integer(__n);
    using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
    if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
{
 if (__n2 <= 0)
   return __first;
 auto __last = __first + __n2;
 std::for_each(__first, __last, std::move(__f));
 return __last;
}
    else
{
 while (__n2-->0)
   {
     __f(*__first);
     ++__first;
   }
 return __first;
}
  }
3880#endif // C++17

/**
 *  @brief Find the first occurrence of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __val    The value to find.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @c *i == @p __val, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__iter_equals_val(__val));
  }

/**
 *  @brief Find the first element in a sequence for which a
 *         predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Find element from a set in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an
 *  iterator in [__first2,__last2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (*__first1 == *__iter)
   return __first1;
    return __last1;
  }

/**
 *  @brief  Find element from a set in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @param  __comp    Predicate to use.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true
 *  and i2 is an iterator in [__first2,__last2), or @p __last1 if no
 *  such iterator exists.
 *

 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2,
  _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (__comp(*__first1, *__iter))
   return __first1;
    return __last1;
  }

/**
 *  @brief Find two adjacent values in a sequence that are equal.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1),
 *  or @p __last if no such iterator exists.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
		  __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Find two adjacent values in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first         A forward iterator.
 *  @param  __last          A forward iterator.
 *  @param  __binary_pred   A binary predicate.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that
 *  @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator
 *  exists.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  @brief Count the number of copies of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be counted.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @c *i == @p __value
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Count the elements of a sequence for which a predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @p __pred(*i) is true.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief Search a sequence for a matching sub-sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  A forward iterator.
 *  @param  __last1   A forward iterator.
 *  @param  __first2  A forward iterator.
 *  @param  __last2   A forward iterator.
 *  @return The first iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p
 *  *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the first element
 *  of the sub-sequence, or @p __last1 if the sub-sequence is not
 *  found.
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.
 *
 *  This means that the returned iterator @c i will be in the range
 *  @p [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Search a sequence for a matching sub-sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1     A forward iterator.
 *  @param  __last1      A forward iterator.
 *  @param  __first2     A forward iterator.
 *  @param  __last2      A forward iterator.
 *  @param  __predicate  A binary predicate.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that
 *  @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range
 *  @p [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2), using @p __predicate to determine equality,
 *  and returns an iterator to the first element of the
 *  sub-sequence, or @p __last1 if no such iterator exists.
 *
 *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2,
  _BinaryPredicate  __predicate)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_comp_iter(__predicate));
  }

/**
 *  @brief Search a sequence for a number of consecutive values.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __count  The number of consecutive values.
 *  @param  __val    The value to find.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @c *(i+N) == @p __val for
 *  each @c N in the range @p [0,__count), or @p __last if no such
 *  iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p count consecutive elements
 *  equal to @p __val.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
	     __gnu_cxx::__ops::__iter_equals_val(__val));
  }


/**
 *  @brief Search a sequence for a number of consecutive values using a
 *         predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __count        The number of consecutive values.
 *  @param  __val          The value to find.
 *  @param  __binary_pred  A binary predicate.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @p
 *  __binary_pred(*(i+N),__val) is true for each @c N in the range
 *  @p [0,__count), or @p __last if no such iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p __count
 *  consecutive elements for which the predicate returns true.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val,
    _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
  }

4267#if __cplusplus201402L > 201402L
/** @brief Search a sequence using a Searcher object.
 *
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __searcher     A callable object.
 *  @return @p __searcher(__first,__last).first
*/
template<typename _ForwardIterator, typename _Searcher>
  inline _ForwardIterator
  search(_ForwardIterator __first, _ForwardIterator __last,
  const _Searcher& __searcher)
  { return __searcher(__first, __last).first; }
4280#endif

/**
 *  @brief Perform an operation on a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first     An input iterator.
 *  @param  __last      An input iterator.
 *  @param  __result    An output iterator.
 *  @param  __unary_op  A unary operator.
 *  @return   An output iterator equal to @p __result+(__last-__first).
 *
 *  Applies the operator to each element in the input range and assigns
 *  the results to successive elements of the output sequence.
 *  Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the
 *  range @p [0,__last-__first).
 *
 *  @p unary_op must not alter its argument.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _UnaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _UnaryOperation __unary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _UnaryOperation"
   __typeof__(__unary_op(*__first))>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first, (void)++__result)
*__result = __unary_op(*__first);
    return __result;
  }

/**
 *  @brief Perform an operation on corresponding elements of two sequences.
 *  @ingroup mutating_algorithms
 *  @param  __first1     An input iterator.
 *  @param  __last1      An input iterator.
 *  @param  __first2     An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __binary_op  A binary operator.
 *  @return   An output iterator equal to @p result+(last-first).
 *
 *  Applies the operator to the corresponding elements in the two
 *  input ranges and assigns the results to successive elements of the
 *  output sequence.
 *  Evaluates @p
 *  *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each
 *  @c N in the range @p [0,__last1-__first1).
 *
 *  @p binary_op must not alter either of its arguments.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _BinaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _OutputIterator __result,
     _BinaryOperation __binary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _BinaryOperation"
   __typeof__(__binary_op(*__first1,*__first2))>)
    __glibcxx_requires_valid_range(__first1, __last1);

    for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2);
    return __result;
  }

/**
 *  @brief Replace each occurrence of one value in a sequence with another
 *         value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   replace() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @c *i ==
 *  @p __old_value then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace(_ForwardIterator __first, _ForwardIterator __last,
   const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (*__first == __old_value)
 *__first = __new_value;
  }

/**
 *  @brief Replace each value in a sequence for which a predicate returns
 *         true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   replace_if() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
 *  is true then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace_if(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 *__first = __new_value;
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   generate() returns no value.
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__last).
*/
template<typename _ForwardIterator, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  void
  generate(_ForwardIterator __first, _ForwardIterator __last,
    _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_GeneratorConcept<_Generator,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
*__first = __gen();
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __n      The length of the sequence.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   The end of the sequence, @p __first+__n
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__first+__n).
 *
 * If @p __n is negative, the function does nothing and returns @p __first.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 865. More algorithms that throw away information
// DR 426. search_n(), fill_n(), and generate_n() with negative n
template<typename _OutputIterator, typename _Size, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _Generator"
   __typeof__(__gen())>)

    typedef __decltype(std::__size_to_integer(__n)) _IntSize;
    for (_IntSize __niter = std::__size_to_integer(__n);
  __niter > 0; --__niter, (void) ++__first)
*__first = __gen();
    return __first;
  }

/**
 *  @brief Copy a sequence, removing consecutive duplicate values.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements that compare equal.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
 *  
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 538. 241 again: Does unique_copy() require CopyConstructible and 
 *  Assignable?
*/
template<typename _InputIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
		__gnu_cxx::__ops::__iter_equal_to_iter(),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

/**
 *  @brief Copy a sequence, removing consecutive values using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        An input iterator.
 *  @param  __last         An input iterator.
 *  @param  __result       An output iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements for which @p __binary_pred returns
 *  true.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
  {
    // concept requirements -- predicates checked later
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

4571#if _GLIBCXX_HOSTED1
/**
 *  @brief Randomly shuffle the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  Nothing.
 *
 *  Reorder the elements in the range @p [__first,__last) using a random
 *  distribution, so that every possible ordering of the sequence is
 *  equally likely.
*/
template<typename _RandomAccessIterator>
  inline void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   // XXX rand() % N is not uniformly distributed
   _RandomAccessIterator __j = __first
			+ std::rand() % ((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
  }
4602#endif

/**
 *  @brief Shuffle the elements of a sequence using a random number
 *         generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __rand    The RNG functor or function.
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __rand to
 *  provide a random distribution. Calling @p __rand(N) for a positive
 *  integer @p N should return a randomly chosen integer from the
 *  range [0,N).
*/
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
  void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
4621#if __cplusplus201402L >= 201103L
   _RandomNumberGenerator&& __rand)
4623#else
   _RandomNumberGenerator& __rand)
4625#endif
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;
    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
 _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
 if (__i != __j)
   std::iter_swap(__i, __j);
}
  }


/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [__first,middle) and false for each @p i
 *  in the range @p [middle,__last).
 *
 *  @p __pred must not modify its operand. @p partition() does not preserve
 *  the relative ordering of elements in each group, use
 *  @p stable_partition() if this is needed.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate   __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__partition(__first, __last, __pred,
	      std::__iterator_category(__first));
  }


/**
 *  @brief Sort the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [first,last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then *j<*i and *k<*i are both false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the smallest elements of a sequence using a predicate
 *         for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [__first,__last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i)
 *  are both false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last,
 _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort a sequence just enough to find a particular position.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that *j < *i is false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort a sequence just enough to find a particular position
 *         using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that @p __comp(*j,*i) is false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort the elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @e i in the range @p [__first,__last-1),  
 *  *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
55
←
Calling '__sort<unsigned int *, __gnu_cxx::__ops::_Iter_less_iter>'→
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that @p __comp(*(i+1),*i) is false for every iterator @e i in the
 *  range @p [__first,__last-1).
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @param  __comp    A functor to use for comparisons.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _RandomAccessIterator, typename _Compare>
  inline void
  __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, std::distance(__first, __last));

    if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
    else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
		    _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Sort the elements of a sequence, preserving the relative order
 *         of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p x<y is false and @p y<x is false will have the same relative
 *  ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison,
 *         preserving the relative order of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p __comp(*(i+1),*i) is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p __comp(x,y) is false and @p __comp(y,x) is false will have the same
 *  relative ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator, typename _Compare>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
   }
 else if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Return the union of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that element is copied and the iterator advanced.  If an element is
 *  contained in both ranges, the element from the first range is copied and
 *  both ranges advance.  The output range may not overlap either input
 *  range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the union of two sorted ranges using a comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that element is copied and the iterator advanced.
 *  If an equivalent element according to @p __comp is contained in both
 *  ranges, the element from the first range is copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 ++__first1;
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   *__result = *__first1;
   ++__first1;
   ++__first2;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Return the intersection of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that iterator advances.  If an element is contained in both ranges, the
 *  element from the first range is copied and both ranges advance.  The
 *  output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the intersection of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that iterator advances.  If an element is
 *  contained in both ranges according to @p __comp, the element from the
 *  first range is copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first1, __last1, __result);
  }

/**
 *  @brief Return the difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second, that element is copied and the
 *  iterator advances.  If the current element of the second range is less,
 *  the iterator advances, but no element is copied.  If an element is
 *  contained in both ranges, no elements are copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the difference of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second according to @p __comp, that element
 *  is copied and the iterator advances.  If the current element of the
 *  second range is less, no element is copied and the iterator advances.
 *  If an element is contained in both ranges according to @p __comp, no
 *  elements are copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_symmetric_difference(_InputIterator1 __first1,
	       _InputIterator1 __last1,
	       _InputIterator2 __first2,
	       _InputIterator2 __last2,
	       _OutputIterator __result,
	       _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 {
   *__result = *__first2;
   ++__first2;
   ++__result;
 }
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first2, __last2, 
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other, that element is copied and the iterator advances.  If an
 *  element is contained in both ranges, no elements are copied and both
 *  ranges advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
			__first2, __last2, __result,
			__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges using
 *  comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other according to @p comp, that element is copied and the
 *  iterator advances.  If an element is contained in both ranges according
 *  to @p __comp, no elements are copied and both ranges advance.  The output
 *  range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result,
	     _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__first, __result))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the minimum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the smallest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  inline min_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the minimum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the smallest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last) return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__result, __first))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the maximum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the largest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the maximum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the largest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

5755#if __cplusplus201402L >= 201402L
/// Reservoir sampling algorithm.
template<typename _InputIterator, typename _RandomAccessIterator,
         typename _Size, typename _UniformRandomBitGenerator>
  _RandomAccessIterator
  __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
    _RandomAccessIterator __out, random_access_iterator_tag,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    __distrib_type __d{};
    _Size __sample_sz = 0;
    while (__first != __last && __sample_sz != __n)
{
 __out[__sample_sz++] = *__first;
 ++__first;
}
    for (auto __pop_sz = __sample_sz; __first != __last;
 ++__first, (void) ++__pop_sz)
{
 const auto __k = __d(__g, __param_type{0, __pop_sz});
 if (__k < __n)
   __out[__k] = *__first;
}
    return __out + __sample_sz;
  }

/// Selection sampling algorithm.
template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
         typename _Size, typename _UniformRandomBitGenerator>
  _OutputIterator
  __sample(_ForwardIterator __first, _ForwardIterator __last,
    forward_iterator_tag,
    _OutputIterator __out, _Cat,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    using _USize = make_unsigned_t<_Size>;
    using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
    using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

    __distrib_type __d{};
    _Size __unsampled_sz = std::distance(__first, __last);
    __n = std::min(__n, __unsampled_sz);

    // If possible, we use __gen_two_uniform_ints to efficiently produce
    // two random numbers using a single distribution invocation:

    const __uc_type __urngrange = __g.max() - __g.min();
    if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
      // I.e. (__urngrange >= __unsampled_sz * __unsampled_sz) but without
// wrapping issues.
      {
 while (__n != 0 && __unsampled_sz >= 2)
   {
     const pair<_Size, _Size> __p =
__gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

     --__unsampled_sz;
     if (__p.first < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;

     if (__n == 0) break;

     --__unsampled_sz;
     if (__p.second < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;
   }
      }

    // The loop above is otherwise equivalent to this one-at-a-time version:

    for (; __n != 0; ++__first)
if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
 {
   *__out++ = *__first;
   --__n;
 }
    return __out;
  }

5848#if __cplusplus201402L > 201402L
5849#define __cpp_lib_sample 201603
/// Take a random sample from a population.
template<typename _PopulationIterator, typename _SampleIterator,
         typename _Distance, typename _UniformRandomBitGenerator>
  _SampleIterator
  sample(_PopulationIterator __first, _PopulationIterator __last,
  _SampleIterator __out, _Distance __n,
  _UniformRandomBitGenerator&& __g)
  {
    using __pop_cat = typename
std::iterator_traits<_PopulationIterator>::iterator_category;
    using __samp_cat = typename
std::iterator_traits<_SampleIterator>::iterator_category;

    static_assert(
 __or_<is_convertible<__pop_cat, forward_iterator_tag>,
is_convertible<__samp_cat, random_access_iterator_tag>>::value,
 "output range must use a RandomAccessIterator when input range"
 " does not meet the ForwardIterator requirements");

    static_assert(is_integral<_Distance>::value,
    "sample size must be an integer type");

    typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
    return _GLIBCXX_STD_Astd::
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
 std::forward<_UniformRandomBitGenerator>(__g));
  }
5877#endif // C++17
5878#endif // C++14

5880_GLIBCXX_END_NAMESPACE_ALGO
5881_GLIBCXX_END_NAMESPACE_VERSION
5882} // namespace std

5884#endif /* _STL_ALGO_H */

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/predefined_ops.h

1// Default predicates for internal use -*- C++ -*-

3// Copyright (C) 2013-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file predefined_ops.h
*  This is an internal header file, included by other library headers.
*  You should not attempt to use it directly. @headername{algorithm}
*/

30#ifndef _GLIBCXX_PREDEFINED_OPS_H1
31#define _GLIBCXX_PREDEFINED_OPS_H1	1

33namespace __gnu_cxx
34{
35namespace __ops
36{
struct _Iter_less_iter
{
  template<typename _Iterator1, typename _Iterator2>
    _GLIBCXX14_CONSTEXPRconstexpr
    bool
    operator()(_Iterator1 __it1, _Iterator2 __it2) const
    { return *__it1 < *__it2; }
63
←
Use of zero-allocated memory
};

_GLIBCXX14_CONSTEXPRconstexpr
inline _Iter_less_iter
__iter_less_iter()
{ return _Iter_less_iter(); }

struct _Iter_less_val
{
53#if __cplusplus201402L >= 201103L
  constexpr _Iter_less_val() = default;
55#else
  _Iter_less_val() { }
57#endif

  _GLIBCXX20_CONSTEXPR
  explicit
  _Iter_less_val(_Iter_less_iter) { }

  template<typename _Iterator, typename _Value>
    _GLIBCXX20_CONSTEXPR
    bool
    operator()(_Iterator __it, _Value& __val) const
    { return *__it < __val; }
};

_GLIBCXX20_CONSTEXPR
inline _Iter_less_val
__iter_less_val()
{ return _Iter_less_val(); }

_GLIBCXX20_CONSTEXPR
inline _Iter_less_val
__iter_comp_val(_Iter_less_iter)
{ return _Iter_less_val(); }

struct _Val_less_iter
{
82#if __cplusplus201402L >= 201103L
  constexpr _Val_less_iter() = default;
84#else
  _Val_less_iter() { }
86#endif

  _GLIBCXX20_CONSTEXPR
  explicit
  _Val_less_iter(_Iter_less_iter) { }

  template<typename _Value, typename _Iterator>
    _GLIBCXX20_CONSTEXPR
    bool
    operator()(_Value& __val, _Iterator __it) const
    { return __val < *__it; }
};

_GLIBCXX20_CONSTEXPR
inline _Val_less_iter
__val_less_iter()
{ return _Val_less_iter(); }

_GLIBCXX20_CONSTEXPR
inline _Val_less_iter
__val_comp_iter(_Iter_less_iter)
{ return _Val_less_iter(); }

struct _Iter_equal_to_iter
{
  template<typename _Iterator1, typename _Iterator2>
    _GLIBCXX20_CONSTEXPR
    bool
    operator()(_Iterator1 __it1, _Iterator2 __it2) const
    { return *__it1 == *__it2; }
};

_GLIBCXX20_CONSTEXPR
inline _Iter_equal_to_iter
__iter_equal_to_iter()
{ return _Iter_equal_to_iter(); }

struct _Iter_equal_to_val
{
  template<typename _Iterator, typename _Value>
    _GLIBCXX20_CONSTEXPR
    bool
    operator()(_Iterator __it, _Value& __val) const
    { return *__it == __val; }
};

_GLIBCXX20_CONSTEXPR
inline _Iter_equal_to_val
__iter_equal_to_val()
{ return _Iter_equal_to_val(); }

_GLIBCXX20_CONSTEXPR
inline _Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
{ return _Iter_equal_to_val(); }

template<typename _Compare>
  struct _Iter_comp_iter
  {
    _Compare _M_comp;

    explicit _GLIBCXX14_CONSTEXPRconstexpr
    _Iter_comp_iter(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp)std::move(__comp))
    { }

    template<typename _Iterator1, typename _Iterator2>
      _GLIBCXX14_CONSTEXPRconstexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2)
      { return bool(_M_comp(*__it1, *__it2)); }
  };

template<typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Iter_comp_iter<_Compare>
  __iter_comp_iter(_Compare __comp)
  { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)std::move(__comp)); }

template<typename _Compare>
  struct _Iter_comp_val
  {
    _Compare _M_comp;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_comp_val(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp)std::move(__comp))
    { }

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
: _M_comp(__comp._M_comp)
    { }

182#if __cplusplus201402L >= 201103L
    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
    { }
188#endif

    template<typename _Iterator, typename _Value>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it, _Value& __val)
{ return bool(_M_comp(*__it, __val)); }
  };

template<typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_comp_val<_Compare>
  __iter_comp_val(_Compare __comp)
  { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)std::move(__comp)); }

template<typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_comp_val<_Compare>
  __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
  { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)std::move(__comp)); }

template<typename _Compare>
  struct _Val_comp_iter
  {
    _Compare _M_comp;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Val_comp_iter(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp)std::move(__comp))
    { }

    _GLIBCXX20_CONSTEXPR
    explicit
    _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
: _M_comp(__comp._M_comp)
    { }

226#if __cplusplus201402L >= 201103L
    _GLIBCXX20_CONSTEXPR
    explicit
    _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
    { }
232#endif

    template<typename _Value, typename _Iterator>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Value& __val, _Iterator __it)
{ return bool(_M_comp(__val, *__it)); }
  };

template<typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _Val_comp_iter<_Compare>
  __val_comp_iter(_Compare __comp)
  { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)std::move(__comp)); }

template<typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _Val_comp_iter<_Compare>
  __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
  { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)std::move(__comp)); }

template<typename _Value>
  struct _Iter_equals_val
  {
    _Value& _M_value;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_equals_val(_Value& __value)
: _M_value(__value)
    { }

    template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it)
{ return *__it == _M_value; }
  };

template<typename _Value>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_equals_val<_Value>
  __iter_equals_val(_Value& __val)
  { return _Iter_equals_val<_Value>(__val); }

template<typename _Iterator1>
  struct _Iter_equals_iter
  {
    _Iterator1 _M_it1;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_equals_iter(_Iterator1 __it1)
: _M_it1(__it1)
    { }

    template<typename _Iterator2>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator2 __it2)
{ return *__it2 == *_M_it1; }
  };

template<typename _Iterator>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_equals_iter<_Iterator>
  __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
  { return _Iter_equals_iter<_Iterator>(__it); }

template<typename _Predicate>
  struct _Iter_pred
  {
    _Predicate _M_pred;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_pred(_Predicate __pred)
: _M_pred(_GLIBCXX_MOVE(__pred)std::move(__pred))
    { }

    template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it)
{ return bool(_M_pred(*__it)); }
  };

template<typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_pred<_Predicate>
  __pred_iter(_Predicate __pred)
  { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)std::move(__pred)); }

template<typename _Compare, typename _Value>
  struct _Iter_comp_to_val
  {
    _Compare _M_comp;
    _Value& _M_value;

    _GLIBCXX20_CONSTEXPR
    _Iter_comp_to_val(_Compare __comp, _Value& __value)
: _M_comp(_GLIBCXX_MOVE(__comp)std::move(__comp)), _M_value(__value)
    { }

    template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it)
{ return bool(_M_comp(*__it, _M_value)); }
  };

template<typename _Compare, typename _Value>
  _Iter_comp_to_val<_Compare, _Value>
  _GLIBCXX20_CONSTEXPR
  __iter_comp_val(_Compare __comp, _Value &__val)
  {
    return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp)std::move(__comp), __val);
  }

template<typename _Compare, typename _Iterator1>
  struct _Iter_comp_to_iter
  {
    _Compare _M_comp;
    _Iterator1 _M_it1;

    _GLIBCXX20_CONSTEXPR
    _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
: _M_comp(_GLIBCXX_MOVE(__comp)std::move(__comp)), _M_it1(__it1)
    { }

    template<typename _Iterator2>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator2 __it2)
{ return bool(_M_comp(*__it2, *_M_it1)); }
  };

template<typename _Compare, typename _Iterator>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_comp_to_iter<_Compare, _Iterator>
  __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
  {
    return _Iter_comp_to_iter<_Compare, _Iterator>(
 _GLIBCXX_MOVE(__comp._M_comp)std::move(__comp._M_comp), __it);
  }

template<typename _Predicate>
  struct _Iter_negate
  {
    _Predicate _M_pred;

    _GLIBCXX20_CONSTEXPR
    explicit
    _Iter_negate(_Predicate __pred)
: _M_pred(_GLIBCXX_MOVE(__pred)std::move(__pred))
    { }

    template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it)
{ return !bool(_M_pred(*__it)); }
  };

template<typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _Iter_negate<_Predicate>
  __negate(_Iter_pred<_Predicate> __pred)
  { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)std::move(__pred._M_pred)); }

402} // namespace __ops
403} // namespace __gnu_cxx

405#endif