constraint_solver.h

Go to the documentation of this file.

// Copyright 2010-2018 Google LLC
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
 
#ifndef OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_
#define OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_
 
#include <functional>
#include <iosfwd>
#include <memory>
#include <random>
#include <string>
#include <utility>
#include <vector>
 
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/random/distributions.h"
#include "absl/random/random.h"
#include "absl/strings/str_format.h"
#include "ortools/base/commandlineflags.h"
#include "ortools/base/hash.h"
#include "ortools/base/integral_types.h"
#include "ortools/base/logging.h"
#include "ortools/base/macros.h"
#include "ortools/base/map_util.h"
#include "ortools/base/sysinfo.h"
#include "ortools/base/timer.h"
#include "ortools/constraint_solver/solver_parameters.pb.h"
#include "ortools/util/piecewise_linear_function.h"
#include "ortools/util/sorted_interval_list.h"
#include "ortools/util/tuple_set.h"
 
#if !defined(SWIG)
DECLARE_int64(cp_random_seed);
#endif  // !defined(SWIG)
 
class File;
 
namespace operations_research {
 
class Assignment;
class AssignmentProto;
class BaseObject;
class CpArgument;
class CpConstraint;
class CpIntegerExpression;
class CpIntervalVariable;
class CpSequenceVariable;
class CastConstraint;
class Constraint;
class Decision;
class DecisionBuilder;
class DecisionVisitor;
class Demon;
class DemonProfiler;
class LocalSearchProfiler;
class Dimension;
class DisjunctiveConstraint;
class ExpressionCache;
class IntExpr;
class IntTupleSet;
class IntVar;
class IntVarAssignment;
class IntVarElement;
class IntervalVar;
class IntervalVarAssignment;
class IntervalVarElement;
class IntVarLocalSearchFilter;
class LocalSearchFilter;
class LocalSearchOperator;
class LocalSearchPhaseParameters;
class ModelCache;
class ModelVisitor;
class OptimizeVar;
class Pack;
class PropagationBaseObject;
class PropagationMonitor;
class LocalSearchMonitor;
class Queue;
class RevBitMatrix;
class RevBitSet;
class RegularLimit;
class RegularLimitParameters;
class Search;
class SearchLimit;
class SearchMonitor;
class SequenceVar;
class SequenceVarAssignment;
class SolutionCollector;
class SolutionPool;
class Solver;
class ConstraintSolverParameters;
class SymmetryBreaker;
struct StateInfo;
struct Trail;
template <class T>
class SimpleRevFIFO;
 
inline int64 CpRandomSeed() {
  return FLAGS_cp_random_seed == -1
             ? absl::Uniform<int64>(absl::BitGen(), 0, kint64max)
             : FLAGS_cp_random_seed;
}
 
struct DefaultPhaseParameters {
 public:
  enum VariableSelection {
    CHOOSE_MAX_SUM_IMPACT = 0,
    CHOOSE_MAX_AVERAGE_IMPACT = 1,
    CHOOSE_MAX_VALUE_IMPACT = 2,
  };
 
  enum ValueSelection {
    SELECT_MIN_IMPACT = 0,
    SELECT_MAX_IMPACT = 1,
  };
 
  enum DisplayLevel { NONE = 0, NORMAL = 1, VERBOSE = 2 };
 
  VariableSelection var_selection_schema;
 
  ValueSelection value_selection_schema;
 
  int initialization_splits;
 
  bool run_all_heuristics;
 
  int heuristic_period;
 
  int heuristic_num_failures_limit;
 
  bool persistent_impact;
 
  int random_seed;
 
  DisplayLevel display_level;
 
  bool use_last_conflict;
 
  DecisionBuilder* decision_builder;
 
  DefaultPhaseParameters();
};
 
class Solver {
 public:
  struct IntegerCastInfo {
    IntegerCastInfo()
        : variable(nullptr), expression(nullptr), maintainer(nullptr) {}
    IntegerCastInfo(IntVar* const v, IntExpr* const e, Constraint* const c)
        : variable(v), expression(e), maintainer(c) {}
    IntVar* variable;
    IntExpr* expression;
    Constraint* maintainer;
  };
 
  static const int kNumPriorities = 3;
 
  enum IntVarStrategy {
    INT_VAR_DEFAULT,
 
    INT_VAR_SIMPLE,
 
    CHOOSE_FIRST_UNBOUND,
 
    CHOOSE_RANDOM,
 
    CHOOSE_MIN_SIZE_LOWEST_MIN,
 
    CHOOSE_MIN_SIZE_HIGHEST_MIN,
 
    CHOOSE_MIN_SIZE_LOWEST_MAX,
 
    CHOOSE_MIN_SIZE_HIGHEST_MAX,
 
    CHOOSE_LOWEST_MIN,
 
    CHOOSE_HIGHEST_MAX,
 
    CHOOSE_MIN_SIZE,
 
    CHOOSE_MAX_SIZE,
 
    CHOOSE_MAX_REGRET_ON_MIN,
 
    CHOOSE_PATH,
  };
  // TODO(user): add HIGHEST_MIN and LOWEST_MAX.
 
  enum IntValueStrategy {
    INT_VALUE_DEFAULT,
 
    INT_VALUE_SIMPLE,
 
    ASSIGN_MIN_VALUE,
 
    ASSIGN_MAX_VALUE,
 
    ASSIGN_RANDOM_VALUE,
 
    ASSIGN_CENTER_VALUE,
 
    SPLIT_LOWER_HALF,
 
    SPLIT_UPPER_HALF,
  };
 
  enum EvaluatorStrategy {
    CHOOSE_STATIC_GLOBAL_BEST,
 
    CHOOSE_DYNAMIC_GLOBAL_BEST,
  };
 
  enum SequenceStrategy {
    SEQUENCE_DEFAULT,
    SEQUENCE_SIMPLE,
    CHOOSE_MIN_SLACK_RANK_FORWARD,
    CHOOSE_RANDOM_RANK_FORWARD,
  };
 
  enum IntervalStrategy {
    INTERVAL_DEFAULT,
    INTERVAL_SIMPLE,
    INTERVAL_SET_TIMES_FORWARD,
    INTERVAL_SET_TIMES_BACKWARD
  };
 
  enum LocalSearchOperators {
    TWOOPT,
 
    OROPT,
 
    RELOCATE,
 
    EXCHANGE,
 
    CROSS,
 
    MAKEACTIVE,
 
    MAKEINACTIVE,
 
    MAKECHAININACTIVE,
 
    SWAPACTIVE,
 
    EXTENDEDSWAPACTIVE,
 
    PATHLNS,
 
    FULLPATHLNS,
 
    UNACTIVELNS,
 
    INCREMENT,
 
    DECREMENT,
 
    SIMPLELNS
  };
 
  enum EvaluatorLocalSearchOperators {
    LK,
 
    TSPOPT,
 
    TSPLNS
  };
 
  enum LocalSearchFilterBound {
    GE,
    LE,
    EQ
  };
 
  enum DemonPriority {
    DELAYED_PRIORITY = 0,
 
    VAR_PRIORITY = 1,
 
    NORMAL_PRIORITY = 2,
  };
 
  enum BinaryIntervalRelation {
    ENDS_AFTER_END,
 
    ENDS_AFTER_START,
 
    ENDS_AT_END,
 
    ENDS_AT_START,
 
    STARTS_AFTER_END,
 
    STARTS_AFTER_START,
 
    STARTS_AT_END,
 
    STARTS_AT_START,
 
    STAYS_IN_SYNC
  };
 
  enum UnaryIntervalRelation {
    ENDS_AFTER,
 
    ENDS_AT,
 
    ENDS_BEFORE,
 
    STARTS_AFTER,
 
    STARTS_AT,
 
    STARTS_BEFORE,
 
    CROSS_DATE,
 
    AVOID_DATE
  };
 
  enum DecisionModification {
    NO_CHANGE,
 
    KEEP_LEFT,
 
    KEEP_RIGHT,
 
    KILL_BOTH,
 
    SWITCH_BRANCHES
  };
 
  enum MarkerType { SENTINEL, SIMPLE_MARKER, CHOICE_POINT, REVERSIBLE_ACTION };
 
  enum SolverState {
    OUTSIDE_SEARCH,
    IN_ROOT_NODE,
    IN_SEARCH,
    AT_SOLUTION,
    NO_MORE_SOLUTIONS,
    PROBLEM_INFEASIBLE
  };
 
  enum OptimizationDirection { NOT_SET, MAXIMIZATION, MINIMIZATION };
 
  typedef std::function<int64(int64)> IndexEvaluator1;
  typedef std::function<int64(int64, int64)> IndexEvaluator2;
  typedef std::function<int64(int64, int64, int64)> IndexEvaluator3;
 
  typedef std::function<bool(int64)> IndexFilter1;
 
  typedef std::function<IntVar*(int64)> Int64ToIntVar;
 
  typedef std::function<int64(Solver* solver, const std::vector<IntVar*>& vars,
                              int64 first_unbound, int64 last_unbound)>
      VariableIndexSelector;
 
  typedef std::function<int64(const IntVar* v, int64 id)> VariableValueSelector;
  typedef std::function<bool(int64, int64, int64)> VariableValueComparator;
  typedef std::function<DecisionModification()> BranchSelector;
  // TODO(user): wrap in swig.
  typedef std::function<void(Solver*)> Action;
  typedef std::function<void()> Closure;
 
  explicit Solver(const std::string& name);
  Solver(const std::string& name, const ConstraintSolverParameters& parameters);
  ~Solver();
 
  ConstraintSolverParameters parameters() const { return parameters_; }
  // TODO(user): Move to constraint_solver_parameters.h.
  static ConstraintSolverParameters DefaultSolverParameters();
 
 
  template <class T>
  void SaveValue(T* o) {
    InternalSaveValue(o);
  }
 
  template <typename T>
  T* RevAlloc(T* object) {
    return reinterpret_cast<T*>(SafeRevAlloc(object));
  }
 
  template <typename T>
  T* RevAllocArray(T* object) {
    return reinterpret_cast<T*>(SafeRevAllocArray(object));
  }
 
  void AddConstraint(Constraint* const c);
  void AddCastConstraint(CastConstraint* const constraint,
                         IntVar* const target_var, IntExpr* const expr);
 
  bool Solve(DecisionBuilder* const db,
             const std::vector<SearchMonitor*>& monitors);
  bool Solve(DecisionBuilder* const db);
  bool Solve(DecisionBuilder* const db, SearchMonitor* const m1);
  bool Solve(DecisionBuilder* const db, SearchMonitor* const m1,
             SearchMonitor* const m2);
  bool Solve(DecisionBuilder* const db, SearchMonitor* const m1,
             SearchMonitor* const m2, SearchMonitor* const m3);
  bool Solve(DecisionBuilder* const db, SearchMonitor* const m1,
             SearchMonitor* const m2, SearchMonitor* const m3,
             SearchMonitor* const m4);
 
 
  void NewSearch(DecisionBuilder* const db,
                 const std::vector<SearchMonitor*>& monitors);
  void NewSearch(DecisionBuilder* const db);
  void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1);
  void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1,
                 SearchMonitor* const m2);
  void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1,
                 SearchMonitor* const m2, SearchMonitor* const m3);
  void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1,
                 SearchMonitor* const m2, SearchMonitor* const m3,
                 SearchMonitor* const m4);
 
  bool NextSolution();
  void RestartSearch();
  void EndSearch();
 
  bool SolveAndCommit(DecisionBuilder* const db,
                      const std::vector<SearchMonitor*>& monitors);
  bool SolveAndCommit(DecisionBuilder* const db);
  bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1);
  bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1,
                      SearchMonitor* const m2);
  bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1,
                      SearchMonitor* const m2, SearchMonitor* const m3);
 
  bool CheckAssignment(Assignment* const solution);
 
  bool CheckConstraint(Constraint* const ct);
 
  SolverState state() const { return state_; }
 
  void Fail();
 
#if !defined(SWIG)
  void AddBacktrackAction(Action a, bool fast);
#endif  
 
  std::string DebugString() const;
 
  static int64 MemoryUsage();
 
  absl::Time Now() const;
 
  int64 wall_time() const;
 
  int64 branches() const { return branches_; }
 
  int64 solutions() const;
 
  int64 unchecked_solutions() const;
 
  int64 demon_runs(DemonPriority p) const { return demon_runs_[p]; }
 
  int64 failures() const { return fails_; }
 
  int64 neighbors() const { return neighbors_; }
 
  int64 filtered_neighbors() const { return filtered_neighbors_; }
 
  int64 accepted_neighbors() const { return accepted_neighbors_; }
 
  uint64 stamp() const;
 
  uint64 fail_stamp() const;
 
  OptimizationDirection optimization_direction() const {
    return optimization_direction_;
  }
  void set_optimization_direction(OptimizationDirection direction) {
    optimization_direction_ = direction;
  }
 
  // All factories (MakeXXX methods) encapsulate creation of objects
  // through RevAlloc(). Hence, the Solver used for allocating the
  // returned object will retain ownership of the allocated memory.
  // Destructors are called upon backtrack, or when the Solver is
  // itself destructed.
 
  // ----- Int Variables and Constants -----
 
  IntVar* MakeIntVar(int64 min, int64 max, const std::string& name);
 
  IntVar* MakeIntVar(const std::vector<int64>& values, const std::string& name);
 
  IntVar* MakeIntVar(const std::vector<int>& values, const std::string& name);
 
  IntVar* MakeIntVar(int64 min, int64 max);
 
  IntVar* MakeIntVar(const std::vector<int64>& values);
 
  IntVar* MakeIntVar(const std::vector<int>& values);
 
  IntVar* MakeBoolVar(const std::string& name);
 
  IntVar* MakeBoolVar();
 
  IntVar* MakeIntConst(int64 val, const std::string& name);
 
  IntVar* MakeIntConst(int64 val);
 
  void MakeIntVarArray(int var_count, int64 vmin, int64 vmax,
                       const std::string& name, std::vector<IntVar*>* vars);
  void MakeIntVarArray(int var_count, int64 vmin, int64 vmax,
                       std::vector<IntVar*>* vars);
  IntVar** MakeIntVarArray(int var_count, int64 vmin, int64 vmax,
                           const std::string& name);
 
  void MakeBoolVarArray(int var_count, const std::string& name,
                        std::vector<IntVar*>* vars);
  void MakeBoolVarArray(int var_count, std::vector<IntVar*>* vars);
  IntVar** MakeBoolVarArray(int var_count, const std::string& name);
 
  // ----- Integer Expressions -----
 
  IntExpr* MakeSum(IntExpr* const left, IntExpr* const right);
  IntExpr* MakeSum(IntExpr* const expr, int64 value);
  IntExpr* MakeSum(const std::vector<IntVar*>& vars);
 
  IntExpr* MakeScalProd(const std::vector<IntVar*>& vars,
                        const std::vector<int64>& coefs);
  IntExpr* MakeScalProd(const std::vector<IntVar*>& vars,
                        const std::vector<int>& coefs);
 
  IntExpr* MakeDifference(IntExpr* const left, IntExpr* const right);
  IntExpr* MakeDifference(int64 value, IntExpr* const expr);
  IntExpr* MakeOpposite(IntExpr* const expr);
 
  IntExpr* MakeProd(IntExpr* const left, IntExpr* const right);
  IntExpr* MakeProd(IntExpr* const expr, int64 value);
 
  IntExpr* MakeDiv(IntExpr* const expr, int64 value);
  IntExpr* MakeDiv(IntExpr* const numerator, IntExpr* const denominator);
 
  IntExpr* MakeAbs(IntExpr* const expr);
  IntExpr* MakeSquare(IntExpr* const expr);
  IntExpr* MakePower(IntExpr* const expr, int64 n);
 
  IntExpr* MakeElement(const std::vector<int64>& values, IntVar* const index);
  IntExpr* MakeElement(const std::vector<int>& values, IntVar* const index);
 
  IntExpr* MakeElement(IndexEvaluator1 values, IntVar* const index);
  IntExpr* MakeMonotonicElement(IndexEvaluator1 values, bool increasing,
                                IntVar* const index);
  IntExpr* MakeElement(IndexEvaluator2 values, IntVar* const index1,
                       IntVar* const index2);
 
  IntExpr* MakeElement(const std::vector<IntVar*>& vars, IntVar* const index);
 
#if !defined(SWIG)
  IntExpr* MakeElement(Int64ToIntVar vars, int64 range_start, int64 range_end,
                       IntVar* argument);
#endif  // SWIG
 
  IntExpr* MakeIndexExpression(const std::vector<IntVar*>& vars, int64 value);
 
  Constraint* MakeIfThenElseCt(IntVar* const condition,
                               IntExpr* const then_expr,
                               IntExpr* const else_expr,
                               IntVar* const target_var);
 
  IntExpr* MakeMin(const std::vector<IntVar*>& vars);
  IntExpr* MakeMin(IntExpr* const left, IntExpr* const right);
  IntExpr* MakeMin(IntExpr* const expr, int64 value);
  IntExpr* MakeMin(IntExpr* const expr, int value);
 
  IntExpr* MakeMax(const std::vector<IntVar*>& vars);
  IntExpr* MakeMax(IntExpr* const left, IntExpr* const right);
  IntExpr* MakeMax(IntExpr* const expr, int64 value);
  IntExpr* MakeMax(IntExpr* const expr, int value);
 
  IntExpr* MakeConvexPiecewiseExpr(IntExpr* expr, int64 early_cost,
                                   int64 early_date, int64 late_date,
                                   int64 late_cost);
 
  IntExpr* MakeSemiContinuousExpr(IntExpr* const expr, int64 fixed_charge,
                                  int64 step);
 
  // TODO(user): Investigate if we can merge all three piecewise linear
#ifndef SWIG
  IntExpr* MakePiecewiseLinearExpr(IntExpr* expr,
                                   const PiecewiseLinearFunction& f);
#endif
 
  IntExpr* MakeModulo(IntExpr* const x, int64 mod);
 
  IntExpr* MakeModulo(IntExpr* const x, IntExpr* const mod);
 
  IntExpr* MakeConditionalExpression(IntVar* const condition,
                                     IntExpr* const expr,
                                     int64 unperformed_value);
 
  Constraint* MakeTrueConstraint();
  Constraint* MakeFalseConstraint();
  Constraint* MakeFalseConstraint(const std::string& explanation);
 
  Constraint* MakeIsEqualCstCt(IntExpr* const var, int64 value,
                               IntVar* const boolvar);
  IntVar* MakeIsEqualCstVar(IntExpr* const var, int64 value);
  Constraint* MakeIsEqualCt(IntExpr* const v1, IntExpr* v2, IntVar* const b);
  IntVar* MakeIsEqualVar(IntExpr* const v1, IntExpr* v2);
  Constraint* MakeEquality(IntExpr* const left, IntExpr* const right);
  Constraint* MakeEquality(IntExpr* const expr, int64 value);
  Constraint* MakeEquality(IntExpr* const expr, int value);
 
  Constraint* MakeIsDifferentCstCt(IntExpr* const var, int64 value,
                                   IntVar* const boolvar);
  IntVar* MakeIsDifferentCstVar(IntExpr* const var, int64 value);
  IntVar* MakeIsDifferentVar(IntExpr* const v1, IntExpr* const v2);
  Constraint* MakeIsDifferentCt(IntExpr* const v1, IntExpr* const v2,
                                IntVar* const b);
  Constraint* MakeNonEquality(IntExpr* const left, IntExpr* const right);
  Constraint* MakeNonEquality(IntExpr* const expr, int64 value);
  Constraint* MakeNonEquality(IntExpr* const expr, int value);
 
  Constraint* MakeIsLessOrEqualCstCt(IntExpr* const var, int64 value,
                                     IntVar* const boolvar);
  IntVar* MakeIsLessOrEqualCstVar(IntExpr* const var, int64 value);
  IntVar* MakeIsLessOrEqualVar(IntExpr* const left, IntExpr* const right);
  Constraint* MakeIsLessOrEqualCt(IntExpr* const left, IntExpr* const right,
                                  IntVar* const b);
  Constraint* MakeLessOrEqual(IntExpr* const left, IntExpr* const right);
  Constraint* MakeLessOrEqual(IntExpr* const expr, int64 value);
  Constraint* MakeLessOrEqual(IntExpr* const expr, int value);
 
  Constraint* MakeIsGreaterOrEqualCstCt(IntExpr* const var, int64 value,
                                        IntVar* const boolvar);
  IntVar* MakeIsGreaterOrEqualCstVar(IntExpr* const var, int64 value);
  IntVar* MakeIsGreaterOrEqualVar(IntExpr* const left, IntExpr* const right);
  Constraint* MakeIsGreaterOrEqualCt(IntExpr* const left, IntExpr* const right,
                                     IntVar* const b);
  Constraint* MakeGreaterOrEqual(IntExpr* const left, IntExpr* const right);
  Constraint* MakeGreaterOrEqual(IntExpr* const expr, int64 value);
  Constraint* MakeGreaterOrEqual(IntExpr* const expr, int value);
 
  Constraint* MakeIsGreaterCstCt(IntExpr* const v, int64 c, IntVar* const b);
  IntVar* MakeIsGreaterCstVar(IntExpr* const var, int64 value);
  IntVar* MakeIsGreaterVar(IntExpr* const left, IntExpr* const right);
  Constraint* MakeIsGreaterCt(IntExpr* const left, IntExpr* const right,
                              IntVar* const b);
  Constraint* MakeGreater(IntExpr* const left, IntExpr* const right);
  Constraint* MakeGreater(IntExpr* const expr, int64 value);
  Constraint* MakeGreater(IntExpr* const expr, int value);
 
  Constraint* MakeIsLessCstCt(IntExpr* const v, int64 c, IntVar* const b);
  IntVar* MakeIsLessCstVar(IntExpr* const var, int64 value);
  IntVar* MakeIsLessVar(IntExpr* const left, IntExpr* const right);
  Constraint* MakeIsLessCt(IntExpr* const left, IntExpr* const right,
                           IntVar* const b);
  Constraint* MakeLess(IntExpr* const left, IntExpr* const right);
  Constraint* MakeLess(IntExpr* const expr, int64 value);
  Constraint* MakeLess(IntExpr* const expr, int value);
 
  Constraint* MakeSumLessOrEqual(const std::vector<IntVar*>& vars, int64 cst);
  Constraint* MakeSumGreaterOrEqual(const std::vector<IntVar*>& vars,
                                    int64 cst);
  Constraint* MakeSumEquality(const std::vector<IntVar*>& vars, int64 cst);
  Constraint* MakeSumEquality(const std::vector<IntVar*>& vars,
                              IntVar* const var);
  Constraint* MakeScalProdEquality(const std::vector<IntVar*>& vars,
                                   const std::vector<int64>& coefficients,
                                   int64 cst);
  Constraint* MakeScalProdEquality(const std::vector<IntVar*>& vars,
                                   const std::vector<int>& coefficients,
                                   int64 cst);
  Constraint* MakeScalProdEquality(const std::vector<IntVar*>& vars,
                                   const std::vector<int64>& coefficients,
                                   IntVar* const target);
  Constraint* MakeScalProdEquality(const std::vector<IntVar*>& vars,
                                   const std::vector<int>& coefficients,
                                   IntVar* const target);
  Constraint* MakeScalProdGreaterOrEqual(const std::vector<IntVar*>& vars,
                                         const std::vector<int64>& coeffs,
                                         int64 cst);
  Constraint* MakeScalProdGreaterOrEqual(const std::vector<IntVar*>& vars,
                                         const std::vector<int>& coeffs,
                                         int64 cst);
  Constraint* MakeScalProdLessOrEqual(const std::vector<IntVar*>& vars,
                                      const std::vector<int64>& coefficients,
                                      int64 cst);
  Constraint* MakeScalProdLessOrEqual(const std::vector<IntVar*>& vars,
                                      const std::vector<int>& coefficients,
                                      int64 cst);
 
  Constraint* MakeMinEquality(const std::vector<IntVar*>& vars,
                              IntVar* const min_var);
  Constraint* MakeMaxEquality(const std::vector<IntVar*>& vars,
                              IntVar* const max_var);
 
  Constraint* MakeElementEquality(const std::vector<int64>& vals,
                                  IntVar* const index, IntVar* const target);
  Constraint* MakeElementEquality(const std::vector<int>& vals,
                                  IntVar* const index, IntVar* const target);
  Constraint* MakeElementEquality(const std::vector<IntVar*>& vars,
                                  IntVar* const index, IntVar* const target);
  Constraint* MakeElementEquality(const std::vector<IntVar*>& vars,
                                  IntVar* const index, int64 target);
  Constraint* MakeAbsEquality(IntVar* const var, IntVar* const abs_var);
  Constraint* MakeIndexOfConstraint(const std::vector<IntVar*>& vars,
                                    IntVar* const index, int64 target);
 
  Demon* MakeConstraintInitialPropagateCallback(Constraint* const ct);
  Demon* MakeDelayedConstraintInitialPropagateCallback(Constraint* const ct);
#if !defined(SWIG)
  Demon* MakeActionDemon(Action action);
#endif  
  Demon* MakeClosureDemon(Closure closure);
 
  // ----- Between and related constraints -----
 
  Constraint* MakeBetweenCt(IntExpr* const expr, int64 l, int64 u);
 
  Constraint* MakeNotBetweenCt(IntExpr* const expr, int64 l, int64 u);
 
  Constraint* MakeIsBetweenCt(IntExpr* const expr, int64 l, int64 u,
                              IntVar* const b);
  IntVar* MakeIsBetweenVar(IntExpr* const v, int64 l, int64 u);
 
  // ----- Member and related constraints -----
 
  Constraint* MakeMemberCt(IntExpr* const expr,
                           const std::vector<int64>& values);
  Constraint* MakeMemberCt(IntExpr* const expr, const std::vector<int>& values);
 
  Constraint* MakeNotMemberCt(IntExpr* const expr,
                              const std::vector<int64>& values);
  Constraint* MakeNotMemberCt(IntExpr* const expr,
                              const std::vector<int>& values);
 
  Constraint* MakeNotMemberCt(IntExpr* const expr, std::vector<int64> starts,
                              std::vector<int64> ends);
  Constraint* MakeNotMemberCt(IntExpr* const expr, std::vector<int> starts,
                              std::vector<int> ends);
#if !defined(SWIG)
  Constraint* MakeNotMemberCt(IntExpr* expr,
                              SortedDisjointIntervalList intervals);
#endif  // !defined(SWIG)
 
  Constraint* MakeIsMemberCt(IntExpr* const expr,
                             const std::vector<int64>& values,
                             IntVar* const boolvar);
  Constraint* MakeIsMemberCt(IntExpr* const expr,
                             const std::vector<int>& values,
                             IntVar* const boolvar);
  IntVar* MakeIsMemberVar(IntExpr* const expr,
                          const std::vector<int64>& values);
  IntVar* MakeIsMemberVar(IntExpr* const expr, const std::vector<int>& values);
 
  Constraint* MakeAtMost(std::vector<IntVar*> vars, int64 value,
                         int64 max_count);
  Constraint* MakeCount(const std::vector<IntVar*>& vars, int64 value,
                        int64 max_count);
  Constraint* MakeCount(const std::vector<IntVar*>& vars, int64 value,
                        IntVar* const max_count);
 
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int64>& values,
                             const std::vector<IntVar*>& cards);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int>& values,
                             const std::vector<IntVar*>& cards);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<IntVar*>& cards);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars, int64 card_min,
                             int64 card_max, int64 card_size);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int64>& card_min,
                             const std::vector<int64>& card_max);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int>& card_min,
                             const std::vector<int>& card_max);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int64>& values,
                             const std::vector<int64>& card_min,
                             const std::vector<int64>& card_max);
  Constraint* MakeDistribute(const std::vector<IntVar*>& vars,
                             const std::vector<int>& values,
                             const std::vector<int>& card_min,
                             const std::vector<int>& card_max);
 
  Constraint* MakeDeviation(const std::vector<IntVar*>& vars,
                            IntVar* const deviation_var, int64 total_sum);
 
  Constraint* MakeAllDifferent(const std::vector<IntVar*>& vars);
 
  Constraint* MakeAllDifferent(const std::vector<IntVar*>& vars,
                               bool stronger_propagation);
 
  Constraint* MakeAllDifferentExcept(const std::vector<IntVar*>& vars,
                                     int64 escape_value);
  // TODO(user): Do we need a version with an array of escape values.
 
  Constraint* MakeSortingConstraint(const std::vector<IntVar*>& vars,
                                    const std::vector<IntVar*>& sorted);
  // TODO(user): Add void MakeSortedArray(
  //                             const std::vector<IntVar*>& vars,
  //                             std::vector<IntVar*>* const sorted);
 
  Constraint* MakeLexicalLess(const std::vector<IntVar*>& left,
                              const std::vector<IntVar*>& right);
 
  Constraint* MakeLexicalLessOrEqual(const std::vector<IntVar*>& left,
                                     const std::vector<IntVar*>& right);
 
  Constraint* MakeInversePermutationConstraint(
      const std::vector<IntVar*>& left, const std::vector<IntVar*>& right);
 
  Constraint* MakeIndexOfFirstMaxValueConstraint(
      IntVar* index, const std::vector<IntVar*>& vars);
 
  Constraint* MakeIndexOfFirstMinValueConstraint(
      IntVar* index, const std::vector<IntVar*>& vars);
 
  Constraint* MakeNullIntersect(const std::vector<IntVar*>& first_vars,
                                const std::vector<IntVar*>& second_vars);
 
  Constraint* MakeNullIntersectExcept(const std::vector<IntVar*>& first_vars,
                                      const std::vector<IntVar*>& second_vars,
                                      int64 escape_value);
 
  // TODO(user): Implement MakeAllNullIntersect taking an array of
  // variable vectors.
 
  Constraint* MakeNoCycle(const std::vector<IntVar*>& nexts,
                          const std::vector<IntVar*>& active,
                          IndexFilter1 sink_handler = nullptr);
  Constraint* MakeNoCycle(const std::vector<IntVar*>& nexts,
                          const std::vector<IntVar*>& active,
                          IndexFilter1 sink_handler, bool assume_paths);
 
  Constraint* MakeCircuit(const std::vector<IntVar*>& nexts);
 
  Constraint* MakeSubCircuit(const std::vector<IntVar*>& nexts);
 
  Constraint* MakePathCumul(const std::vector<IntVar*>& nexts,
                            const std::vector<IntVar*>& active,
                            const std::vector<IntVar*>& cumuls,
                            const std::vector<IntVar*>& transits);
  // TODO(user): Merge with other path-cumuls constraints.
  Constraint* MakeDelayedPathCumul(const std::vector<IntVar*>& nexts,
                                   const std::vector<IntVar*>& active,
                                   const std::vector<IntVar*>& cumuls,
                                   const std::vector<IntVar*>& transits);
  Constraint* MakePathCumul(const std::vector<IntVar*>& nexts,
                            const std::vector<IntVar*>& active,
                            const std::vector<IntVar*>& cumuls,
                            IndexEvaluator2 transit_evaluator);
 
  Constraint* MakePathCumul(const std::vector<IntVar*>& nexts,
                            const std::vector<IntVar*>& active,
                            const std::vector<IntVar*>& cumuls,
                            const std::vector<IntVar*>& slacks,
                            IndexEvaluator2 transit_evaluator);
  // TODO(user): Only does checking on WhenBound events on next variables.
  Constraint* MakePathConnected(std::vector<IntVar*> nexts,
                                std::vector<int64> sources,
                                std::vector<int64> sinks,
                                std::vector<IntVar*> status);
#ifndef SWIG
  // TODO(user): This constraint does not make holes in variable domains;
  Constraint* MakePathPrecedenceConstraint(
      std::vector<IntVar*> nexts,
      const std::vector<std::pair<int, int>>& precedences);
  Constraint* MakePathPrecedenceConstraint(
      std::vector<IntVar*> nexts,
      const std::vector<std::pair<int, int>>& precedences,
      const std::vector<int>& lifo_path_starts,
      const std::vector<int>& fifo_path_starts);
  Constraint* MakePathTransitPrecedenceConstraint(
      std::vector<IntVar*> nexts, std::vector<IntVar*> transits,
      const std::vector<std::pair<int, int>>& precedences);
#endif
  Constraint* MakeMapDomain(IntVar* const var,
                            const std::vector<IntVar*>& actives);
 
  Constraint* MakeAllowedAssignments(const std::vector<IntVar*>& vars,
                                     const IntTupleSet& tuples);
 
  Constraint* MakeTransitionConstraint(const std::vector<IntVar*>& vars,
                                       const IntTupleSet& transition_table,
                                       int64 initial_state,
                                       const std::vector<int64>& final_states);
 
  Constraint* MakeTransitionConstraint(const std::vector<IntVar*>& vars,
                                       const IntTupleSet& transition_table,
                                       int64 initial_state,
                                       const std::vector<int>& final_states);
 
#if defined(SWIGPYTHON)
  Constraint* MakeAllowedAssignments(
      const std::vector<IntVar*>& vars,
      const std::vector<std::vector<int64>>& raw_tuples) {
    IntTupleSet tuples(vars.size());
    tuples.InsertAll(raw_tuples);
    return MakeAllowedAssignments(vars, tuples);
  }
 
  Constraint* MakeTransitionConstraint(
      const std::vector<IntVar*>& vars,
      const std::vector<std::vector<int64>>& raw_transitions,
      int64 initial_state, const std::vector<int>& final_states) {
    IntTupleSet transitions(3);
    transitions.InsertAll(raw_transitions);
    return MakeTransitionConstraint(vars, transitions, initial_state,
                                    final_states);
  }
#endif
 
  Constraint* MakeNonOverlappingBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<IntVar*>& x_size, const std::vector<IntVar*>& y_size);
  Constraint* MakeNonOverlappingBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<int64>& x_size, const std::vector<int64>& y_size);
  Constraint* MakeNonOverlappingBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<int>& x_size, const std::vector<int>& y_size);
 
  Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<IntVar*>& x_size, const std::vector<IntVar*>& y_size);
  Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<int64>& x_size, const std::vector<int64>& y_size);
  Constraint* MakeNonOverlappingNonStrictBoxesConstraint(
      const std::vector<IntVar*>& x_vars, const std::vector<IntVar*>& y_vars,
      const std::vector<int>& x_size, const std::vector<int>& y_size);
 
  Pack* MakePack(const std::vector<IntVar*>& vars, int number_of_bins);
 
  IntervalVar* MakeFixedDurationIntervalVar(int64 start_min, int64 start_max,
                                            int64 duration, bool optional,
                                            const std::string& name);
 
  void MakeFixedDurationIntervalVarArray(
      int count, int64 start_min, int64 start_max, int64 duration,
      bool optional, const std::string& name,
      std::vector<IntervalVar*>* const array);
 
  IntervalVar* MakeFixedDurationIntervalVar(IntVar* const start_variable,
                                            int64 duration,
                                            const std::string& name);
 
  IntervalVar* MakeFixedDurationIntervalVar(IntVar* const start_variable,
                                            int64 duration,
                                            IntVar* const performed_variable,
                                            const std::string& name);
 
  void MakeFixedDurationIntervalVarArray(
      const std::vector<IntVar*>& start_variables, int64 duration,
      const std::string& name, std::vector<IntervalVar*>* const array);
 
  void MakeFixedDurationIntervalVarArray(
      const std::vector<IntVar*>& start_variables,
      const std::vector<int64>& durations, const std::string& name,
      std::vector<IntervalVar*>* const array);
  void MakeFixedDurationIntervalVarArray(
      const std::vector<IntVar*>& start_variables,
      const std::vector<int>& durations, const std::string& name,
      std::vector<IntervalVar*>* const array);
 
  void MakeFixedDurationIntervalVarArray(
      const std::vector<IntVar*>& start_variables,
      const std::vector<int64>& durations,
      const std::vector<IntVar*>& performed_variables, const std::string& name,
      std::vector<IntervalVar*>* const array);
 
  void MakeFixedDurationIntervalVarArray(
      const std::vector<IntVar*>& start_variables,
      const std::vector<int>& durations,
      const std::vector<IntVar*>& performed_variables, const std::string& name,
      std::vector<IntervalVar*>* const array);
 
  IntervalVar* MakeFixedInterval(int64 start, int64 duration,
                                 const std::string& name);
 
  IntervalVar* MakeIntervalVar(int64 start_min, int64 start_max,
                               int64 duration_min, int64 duration_max,
                               int64 end_min, int64 end_max, bool optional,
                               const std::string& name);
 
  void MakeIntervalVarArray(int count, int64 start_min, int64 start_max,
                            int64 duration_min, int64 duration_max,
                            int64 end_min, int64 end_max, bool optional,
                            const std::string& name,
                            std::vector<IntervalVar*>* const array);
 
  IntervalVar* MakeMirrorInterval(IntervalVar* const interval_var);
 
  IntervalVar* MakeFixedDurationStartSyncedOnStartIntervalVar(
      IntervalVar* const interval_var, int64 duration, int64 offset);
 
  IntervalVar* MakeFixedDurationStartSyncedOnEndIntervalVar(
      IntervalVar* const interval_var, int64 duration, int64 offset);
 
  IntervalVar* MakeFixedDurationEndSyncedOnStartIntervalVar(
      IntervalVar* const interval_var, int64 duration, int64 offset);
 
  IntervalVar* MakeFixedDurationEndSyncedOnEndIntervalVar(
      IntervalVar* const interval_var, int64 duration, int64 offset);
 
  IntervalVar* MakeIntervalRelaxedMin(IntervalVar* const interval_var);
 
  IntervalVar* MakeIntervalRelaxedMax(IntervalVar* const interval_var);
 
  Constraint* MakeIntervalVarRelation(IntervalVar* const t,
                                      UnaryIntervalRelation r, int64 d);
 
  Constraint* MakeIntervalVarRelation(IntervalVar* const t1,
                                      BinaryIntervalRelation r,
                                      IntervalVar* const t2);
 
  Constraint* MakeIntervalVarRelationWithDelay(IntervalVar* const t1,
                                               BinaryIntervalRelation r,
                                               IntervalVar* const t2,
                                               int64 delay);
 
  Constraint* MakeTemporalDisjunction(IntervalVar* const t1,
                                      IntervalVar* const t2, IntVar* const alt);
 
  Constraint* MakeTemporalDisjunction(IntervalVar* const t1,
                                      IntervalVar* const t2);
 
  DisjunctiveConstraint* MakeDisjunctiveConstraint(
      const std::vector<IntervalVar*>& intervals, const std::string& name);
 
  DisjunctiveConstraint* MakeStrictDisjunctiveConstraint(
      const std::vector<IntervalVar*>& intervals, const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<int64>& demands, int64 capacity,
                             const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<int>& demands, int64 capacity,
                             const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<int64>& demands,
                             IntVar* const capacity, const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<int>& demands,
                             IntVar* const capacity, const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<IntVar*>& demands,
                             int64 capacity, const std::string& name);
 
  Constraint* MakeCumulative(const std::vector<IntervalVar*>& intervals,
                             const std::vector<IntVar*>& demands,
                             IntVar* const capacity, const std::string& name);
 
  Constraint* MakeCover(const std::vector<IntervalVar*>& vars,
                        IntervalVar* const target_var);
 
  Constraint* MakeEquality(IntervalVar* const var1, IntervalVar* const var2);
 
  Assignment* MakeAssignment();
 
  Assignment* MakeAssignment(const Assignment* const a);
 
  SolutionCollector* MakeFirstSolutionCollector(
      const Assignment* const assignment);
  SolutionCollector* MakeFirstSolutionCollector();
 
  SolutionCollector* MakeLastSolutionCollector(
      const Assignment* const assignment);
  SolutionCollector* MakeLastSolutionCollector();
 
  SolutionCollector* MakeBestValueSolutionCollector(
      const Assignment* const assignment, bool maximize);
  SolutionCollector* MakeBestValueSolutionCollector(bool maximize);
 
  SolutionCollector* MakeNBestValueSolutionCollector(
      const Assignment* const assignment, int solution_count, bool maximize);
  SolutionCollector* MakeNBestValueSolutionCollector(int solution_count,
                                                     bool maximize);
 
  SolutionCollector* MakeAllSolutionCollector(
      const Assignment* const assignment);
  SolutionCollector* MakeAllSolutionCollector();
 
  OptimizeVar* MakeMinimize(IntVar* const v, int64 step);
 
  OptimizeVar* MakeMaximize(IntVar* const v, int64 step);
 
  OptimizeVar* MakeOptimize(bool maximize, IntVar* const v, int64 step);
 
  OptimizeVar* MakeWeightedMinimize(const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int64>& weights,
                                    int64 step);
 
  OptimizeVar* MakeWeightedMinimize(const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int>& weights,
                                    int64 step);
 
  OptimizeVar* MakeWeightedMaximize(const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int64>& weights,
                                    int64 step);
 
  OptimizeVar* MakeWeightedMaximize(const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int>& weights,
                                    int64 step);
 
  OptimizeVar* MakeWeightedOptimize(bool maximize,
                                    const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int64>& weights,
                                    int64 step);
 
  OptimizeVar* MakeWeightedOptimize(bool maximize,
                                    const std::vector<IntVar*>& sub_objectives,
                                    const std::vector<int>& weights,
                                    int64 step);
 
 
 
  SearchMonitor* MakeTabuSearch(bool maximize, IntVar* const v, int64 step,
                                const std::vector<IntVar*>& vars,
                                int64 keep_tenure, int64 forbid_tenure,
                                double tabu_factor);
 
  SearchMonitor* MakeGenericTabuSearch(bool maximize, IntVar* const v,
                                       int64 step,
                                       const std::vector<IntVar*>& tabu_vars,
                                       int64 forbid_tenure);
 
  // TODO(user): document behavior
  SearchMonitor* MakeSimulatedAnnealing(bool maximize, IntVar* const v,
                                        int64 step, int64 initial_temperature);
 
  SearchMonitor* MakeGuidedLocalSearch(bool maximize, IntVar* const objective,
                                       IndexEvaluator2 objective_function,
                                       int64 step,
                                       const std::vector<IntVar*>& vars,
                                       double penalty_factor);
  SearchMonitor* MakeGuidedLocalSearch(
      bool maximize, IntVar* const objective,
      IndexEvaluator3 objective_function, int64 step,
      const std::vector<IntVar*>& vars,
      const std::vector<IntVar*>& secondary_vars, double penalty_factor);
 
  SearchMonitor* MakeLubyRestart(int scale_factor);
 
  SearchMonitor* MakeConstantRestart(int frequency);
 
  RegularLimit* MakeTimeLimit(int64 time_in_ms);
 
  RegularLimit* MakeBranchesLimit(int64 branches);
 
  RegularLimit* MakeFailuresLimit(int64 failures);
 
  RegularLimit* MakeSolutionsLimit(int64 solutions);
 
  RegularLimit* MakeLimit(int64 time, int64 branches, int64 failures,
                          int64 solutions);
  RegularLimit* MakeLimit(int64 time, int64 branches, int64 failures,
                          int64 solutions, bool smart_time_check);
  RegularLimit* MakeLimit(int64 time, int64 branches, int64 failures,
                          int64 solutions, bool smart_time_check,
                          bool cumulative);
  RegularLimit* MakeLimit(const RegularLimitParameters& proto);
 
  RegularLimitParameters MakeDefaultRegularLimitParameters() const;
 
  SearchLimit* MakeLimit(SearchLimit* const limit_1,
                         SearchLimit* const limit_2);
 
  SearchLimit* MakeCustomLimit(std::function<bool()> limiter);
 
  // TODO(user): DEPRECATE API of MakeSearchLog(.., IntVar* var,..).
 
  SearchMonitor* MakeSearchLog(int branch_period);
 
  SearchMonitor* MakeSearchLog(int branch_period, IntVar* const var);
 
  SearchMonitor* MakeSearchLog(int branch_period,
                               std::function<std::string()> display_callback);
 
  SearchMonitor* MakeSearchLog(int branch_period, IntVar* var,
                               std::function<std::string()> display_callback);
 
  SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* const opt_var);
 
  SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* const opt_var,
                               std::function<std::string()> display_callback);
 
  struct SearchLogParameters {
    int branch_period = 1;
    OptimizeVar* objective = nullptr;
    IntVar* variable = nullptr;
    double scaling_factor = 1.0;
    double offset = 0;
    std::function<std::string()> display_callback;
  };
  SearchMonitor* MakeSearchLog(SearchLogParameters parameters);
 
  SearchMonitor* MakeSearchTrace(const std::string& prefix);
 
  SearchMonitor* MakeEnterSearchCallback(std::function<void()> callback);
  SearchMonitor* MakeExitSearchCallback(std::function<void()> callback);
  SearchMonitor* MakeAtSolutionCallback(std::function<void()> callback);
 
  ModelVisitor* MakePrintModelVisitor();
  ModelVisitor* MakeStatisticsModelVisitor();
#if !defined(SWIG)
  ModelVisitor* MakeVariableDegreeVisitor(
      absl::flat_hash_map<const IntVar*, int>* const map);
#endif  // !defined(SWIG)
 
  SearchMonitor* MakeSymmetryManager(
      const std::vector<SymmetryBreaker*>& visitors);
  SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1);
  SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1,
                                     SymmetryBreaker* const v2);
  SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1,
                                     SymmetryBreaker* const v2,
                                     SymmetryBreaker* const v3);
  SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1,
                                     SymmetryBreaker* const v2,
                                     SymmetryBreaker* const v3,
                                     SymmetryBreaker* const v4);
 
  Decision* MakeAssignVariableValue(IntVar* const var, int64 val);
  Decision* MakeVariableLessOrEqualValue(IntVar* const var, int64 value);
  Decision* MakeVariableGreaterOrEqualValue(IntVar* const var, int64 value);
  Decision* MakeSplitVariableDomain(IntVar* const var, int64 val,
                                    bool start_with_lower_half);
  Decision* MakeAssignVariableValueOrFail(IntVar* const var, int64 value);
  Decision* MakeAssignVariableValueOrDoNothing(IntVar* const var, int64 value);
  Decision* MakeAssignVariablesValues(const std::vector<IntVar*>& vars,
                                      const std::vector<int64>& values);
  Decision* MakeFailDecision();
  Decision* MakeDecision(Action apply, Action refute);
 
  DecisionBuilder* Compose(DecisionBuilder* const db1,
                           DecisionBuilder* const db2);
  DecisionBuilder* Compose(DecisionBuilder* const db1,
                           DecisionBuilder* const db2,
                           DecisionBuilder* const db3);
  DecisionBuilder* Compose(DecisionBuilder* const db1,
                           DecisionBuilder* const db2,
                           DecisionBuilder* const db3,
                           DecisionBuilder* const db4);
  DecisionBuilder* Compose(const std::vector<DecisionBuilder*>& dbs);
 
  // TODO(user): The search tree can be balanced by using binary
  DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2);
  DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2,
                       DecisionBuilder* const db3);
  DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2,
                       DecisionBuilder* const db3, DecisionBuilder* const db4);
  DecisionBuilder* Try(const std::vector<DecisionBuilder*>& dbs);
 
  // TODO(user): name each of them differently, and document them (and do that
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IntVarStrategy var_str, IntValueStrategy val_str);
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IndexEvaluator1 var_evaluator,
                             IntValueStrategy val_str);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IntVarStrategy var_str,
                             IndexEvaluator2 value_evaluator);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IntVarStrategy var_str,
                             VariableValueComparator var_val1_val2_comparator);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IndexEvaluator1 var_evaluator,
                             IndexEvaluator2 value_evaluator);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IntVarStrategy var_str,
                             IndexEvaluator2 value_evaluator,
                             IndexEvaluator1 tie_breaker);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IndexEvaluator1 var_evaluator,
                             IndexEvaluator2 value_evaluator,
                             IndexEvaluator1 tie_breaker);
 
  DecisionBuilder* MakeDefaultPhase(const std::vector<IntVar*>& vars);
  DecisionBuilder* MakeDefaultPhase(const std::vector<IntVar*>& vars,
                                    const DefaultPhaseParameters& parameters);
 
  DecisionBuilder* MakePhase(IntVar* const v0, IntVarStrategy var_str,
                             IntValueStrategy val_str);
  DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1,
                             IntVarStrategy var_str, IntValueStrategy val_str);
  DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1,
                             IntVar* const v2, IntVarStrategy var_str,
                             IntValueStrategy val_str);
  DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1,
                             IntVar* const v2, IntVar* const v3,
                             IntVarStrategy var_str, IntValueStrategy val_str);
 
  Decision* MakeScheduleOrPostpone(IntervalVar* const var, int64 est,
                                   int64* const marker);
 
  Decision* MakeScheduleOrExpedite(IntervalVar* const var, int64 est,
                                   int64* const marker);
 
  Decision* MakeRankFirstInterval(SequenceVar* const sequence, int index);
 
  Decision* MakeRankLastInterval(SequenceVar* const sequence, int index);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IndexEvaluator2 eval, EvaluatorStrategy str);
 
  DecisionBuilder* MakePhase(const std::vector<IntVar*>& vars,
                             IndexEvaluator2 eval, IndexEvaluator1 tie_breaker,
                             EvaluatorStrategy str);
 
  DecisionBuilder* MakePhase(const std::vector<IntervalVar*>& intervals,
                             IntervalStrategy str);
 
  DecisionBuilder* MakePhase(const std::vector<SequenceVar*>& sequences,
                             SequenceStrategy str);
 
  DecisionBuilder* MakeDecisionBuilderFromAssignment(
      Assignment* const assignment, DecisionBuilder* const db,
      const std::vector<IntVar*>& vars);
 
  DecisionBuilder* MakeConstraintAdder(Constraint* const ct);
 
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db);
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db,
                                 SearchMonitor* const monitor1);
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db,
                                 SearchMonitor* const monitor1,
                                 SearchMonitor* const monitor2);
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db,
                                 SearchMonitor* const monitor1,
                                 SearchMonitor* const monitor2,
                                 SearchMonitor* const monitor3);
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db,
                                 SearchMonitor* const monitor1,
                                 SearchMonitor* const monitor2,
                                 SearchMonitor* const monitor3,
                                 SearchMonitor* const monitor4);
  DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db,
                                 const std::vector<SearchMonitor*>& monitors);
 
  DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db,
                                      Assignment* const solution, bool maximize,
                                      int64 step);
  DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db,
                                      Assignment* const solution, bool maximize,
                                      int64 step,
                                      SearchMonitor* const monitor1);
  DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db,
                                      Assignment* const solution, bool maximize,
                                      int64 step, SearchMonitor* const monitor1,
                                      SearchMonitor* const monitor2);
  DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db,
                                      Assignment* const solution, bool maximize,
                                      int64 step, SearchMonitor* const monitor1,
                                      SearchMonitor* const monitor2,
                                      SearchMonitor* const monitor3);
  DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db,
                                      Assignment* const solution, bool maximize,
                                      int64 step, SearchMonitor* const monitor1,
                                      SearchMonitor* const monitor2,
                                      SearchMonitor* const monitor3,
                                      SearchMonitor* const monitor4);
  DecisionBuilder* MakeNestedOptimize(
      DecisionBuilder* const db, Assignment* const solution, bool maximize,
      int64 step, const std::vector<SearchMonitor*>& monitors);
 
  DecisionBuilder* MakeRestoreAssignment(Assignment* assignment);
 
  DecisionBuilder* MakeStoreAssignment(Assignment* assignment);
 
  LocalSearchOperator* MakeOperator(const std::vector<IntVar*>& vars,
                                    LocalSearchOperators op);
  LocalSearchOperator* MakeOperator(const std::vector<IntVar*>& vars,
                                    const std::vector<IntVar*>& secondary_vars,
                                    LocalSearchOperators op);
  // TODO(user): Make the callback an IndexEvaluator2 when there are no
  // secondary variables.
  LocalSearchOperator* MakeOperator(const std::vector<IntVar*>& vars,
                                    IndexEvaluator3 evaluator,
                                    EvaluatorLocalSearchOperators op);
  LocalSearchOperator* MakeOperator(const std::vector<IntVar*>& vars,
                                    const std::vector<IntVar*>& secondary_vars,
                                    IndexEvaluator3 evaluator,
                                    EvaluatorLocalSearchOperators op);
 
  LocalSearchOperator* MakeRandomLnsOperator(const std::vector<IntVar*>& vars,
                                             int number_of_variables);
  LocalSearchOperator* MakeRandomLnsOperator(const std::vector<IntVar*>& vars,
                                             int number_of_variables,
                                             int32 seed);
 
  LocalSearchOperator* MakeMoveTowardTargetOperator(const Assignment& target);
 
  LocalSearchOperator* MakeMoveTowardTargetOperator(
      const std::vector<IntVar*>& variables,
      const std::vector<int64>& target_values);
 
  LocalSearchOperator* ConcatenateOperators(
      const std::vector<LocalSearchOperator*>& ops);
  LocalSearchOperator* ConcatenateOperators(
      const std::vector<LocalSearchOperator*>& ops, bool restart);
  LocalSearchOperator* ConcatenateOperators(
      const std::vector<LocalSearchOperator*>& ops,
      std::function<int64(int, int)> evaluator);
  LocalSearchOperator* RandomConcatenateOperators(
      const std::vector<LocalSearchOperator*>& ops);
 
  LocalSearchOperator* RandomConcatenateOperators(
      const std::vector<LocalSearchOperator*>& ops, int32 seed);
 
  LocalSearchOperator* MakeNeighborhoodLimit(LocalSearchOperator* const op,
                                             int64 limit);
 
  // TODO(user): Make a variant which runs a local search after each
  //                solution found in a DFS.
 
  DecisionBuilder* MakeLocalSearchPhase(
      Assignment* const assignment,
      LocalSearchPhaseParameters* const parameters);
  DecisionBuilder* MakeLocalSearchPhase(
      const std::vector<IntVar*>& vars, DecisionBuilder* const first_solution,
      LocalSearchPhaseParameters* const parameters);
  DecisionBuilder* MakeLocalSearchPhase(
      const std::vector<IntVar*>& vars, DecisionBuilder* const first_solution,
      DecisionBuilder* const first_solution_sub_decision_builder,
      LocalSearchPhaseParameters* const parameters);
  DecisionBuilder* MakeLocalSearchPhase(
      const std::vector<SequenceVar*>& vars,
      DecisionBuilder* const first_solution,
      LocalSearchPhaseParameters* const parameters);
 
  SolutionPool* MakeDefaultSolutionPool();
 
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder);
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder, RegularLimit* const limit);
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder, RegularLimit* const limit,
      const std::vector<LocalSearchFilter*>& filters);
 
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, SolutionPool* const pool,
      LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder);
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, SolutionPool* const pool,
      LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder, RegularLimit* const limit);
  LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters(
      IntVar* objective, SolutionPool* const pool,
      LocalSearchOperator* const ls_operator,
      DecisionBuilder* const sub_decision_builder, RegularLimit* const limit,
      const std::vector<LocalSearchFilter*>& filters);
 
  LocalSearchFilter* MakeAcceptFilter();
  LocalSearchFilter* MakeRejectFilter();
  LocalSearchFilter* MakeVariableDomainFilter();
  IntVarLocalSearchFilter* MakeSumObjectiveFilter(
      const std::vector<IntVar*>& vars, IndexEvaluator2 values,
      Solver::LocalSearchFilterBound filter_enum);
  IntVarLocalSearchFilter* MakeSumObjectiveFilter(
      const std::vector<IntVar*>& vars,
      const std::vector<IntVar*>& secondary_vars, IndexEvaluator3 values,
      Solver::LocalSearchFilterBound filter_enum);
 
  void TopPeriodicCheck();
  int TopProgressPercent();
 
  void PushState();
  void PopState();
 
  int SearchDepth() const;
 
  int SearchLeftDepth() const;
 
  int SolveDepth() const;
 
  void SetBranchSelector(BranchSelector bs);
 
  DecisionBuilder* MakeApplyBranchSelector(BranchSelector bs);
 
  template <class T>
  void SaveAndSetValue(T* adr, T val) {
    if (*adr != val) {
      InternalSaveValue(adr);
      *adr = val;
    }
  }
 
  template <class T>
  void SaveAndAdd(T* adr, T val) {
    if (val != 0) {
      InternalSaveValue(adr);
      (*adr) += val;
    }
  }
 
  int64 Rand64(int64 size) {
    DCHECK_GT(size, 0);
    return absl::Uniform<int64>(random_, 0, size);
  }
 
  int32 Rand32(int32 size) {
    DCHECK_GT(size, 0);
    return absl::Uniform<int32>(random_, 0, size);
  }
 
  void ReSeed(int32 seed) { random_.seed(seed); }
 
  void ExportProfilingOverview(const std::string& filename);
 
  // TODO(user): Add a profiling protocol buffer and merge demon and local
  std::string LocalSearchProfile() const;
 
  bool CurrentlyInSolve() const;
 
  int constraints() const { return constraints_list_.size(); }
 
  void Accept(ModelVisitor* const visitor) const;
 
  Decision* balancing_decision() const { return balancing_decision_.get(); }
 
#if !defined(SWIG)
  void set_fail_intercept(std::function<void()> fail_intercept) {
    fail_intercept_ = std::move(fail_intercept);
  }
#endif  // !defined(SWIG)
  void clear_fail_intercept() { fail_intercept_ = nullptr; }
  DemonProfiler* demon_profiler() const { return demon_profiler_; }
  // TODO(user): Get rid of the following methods once fast local search is
  void SetUseFastLocalSearch(bool use_fast_local_search) {
    use_fast_local_search_ = use_fast_local_search;
  }
  bool UseFastLocalSearch() const { return use_fast_local_search_; }
  bool HasName(const PropagationBaseObject* object) const;
  Demon* RegisterDemon(Demon* const demon);
  IntExpr* RegisterIntExpr(IntExpr* const expr);
  IntVar* RegisterIntVar(IntVar* const var);
  IntervalVar* RegisterIntervalVar(IntervalVar* const var);
 
  Search* ActiveSearch() const;
  ModelCache* Cache() const;
  bool InstrumentsDemons() const;
  bool IsProfilingEnabled() const;
  bool IsLocalSearchProfilingEnabled() const;
  bool InstrumentsVariables() const;
  bool NameAllVariables() const;
  std::string model_name() const;
  PropagationMonitor* GetPropagationMonitor() const;
  void AddPropagationMonitor(PropagationMonitor* const monitor);
  LocalSearchMonitor* GetLocalSearchMonitor() const;
  void AddLocalSearchMonitor(LocalSearchMonitor* monitor);
  void SetSearchContext(Search* search, const std::string& search_context);
  std::string SearchContext() const;
  std::string SearchContext(const Search* search) const;
  // TODO(user): Investigate if this should be moved to Search.
  Assignment* GetOrCreateLocalSearchState();
  void ClearLocalSearchState() { local_search_state_.reset(nullptr); }
 
  std::vector<int64> tmp_vector_;
 
  friend class BaseIntExpr;
  friend class Constraint;
  friend class DemonProfiler;
  friend class FindOneNeighbor;
  friend class IntVar;
  friend class PropagationBaseObject;
  friend class Queue;
  friend class SearchMonitor;
  friend class SearchLimit;
  friend class RoutingModel;
  friend class LocalSearchProfiler;
 
#if !defined(SWIG)
  friend void InternalSaveBooleanVarValue(Solver* const, IntVar* const);
  template <class>
  friend class SimpleRevFIFO;
  template <class K, class V>
  friend class RevImmutableMultiMap;
 
  bool IsBooleanVar(IntExpr* const expr, IntVar** inner_var,
                    bool* is_negated) const;
 
  bool IsProduct(IntExpr* const expr, IntExpr** inner_expr, int64* coefficient);
#endif  
 
  IntExpr* CastExpression(const IntVar* const var) const;
 
  void FinishCurrentSearch();
  void RestartCurrentSearch();
 
  void ShouldFail() { should_fail_ = true; }
  void CheckFail() {
    if (!should_fail_) return;
    should_fail_ = false;
    Fail();
  }
 
 private:
  void Init();  
  void PushState(MarkerType t, const StateInfo& info);
  MarkerType PopState(StateInfo* info);
  void PushSentinel(int magic_code);
  void BacktrackToSentinel(int magic_code);
  void ProcessConstraints();
  bool BacktrackOneLevel(Decision** fail_decision);
  void JumpToSentinelWhenNested();
  void JumpToSentinel();
  void check_alloc_state();
  void FreezeQueue();
  void EnqueueVar(Demon* const d);
  void EnqueueDelayedDemon(Demon* const d);
  void ExecuteAll(const SimpleRevFIFO<Demon*>& demons);
  void EnqueueAll(const SimpleRevFIFO<Demon*>& demons);
  void UnfreezeQueue();
  void reset_action_on_fail();
  void set_action_on_fail(Action a);
  void set_variable_to_clean_on_fail(IntVar* v);
  void IncrementUncheckedSolutionCounter();
  bool IsUncheckedSolutionLimitReached();
 
  void InternalSaveValue(int* valptr);
  void InternalSaveValue(int64* valptr);
  void InternalSaveValue(uint64* valptr);
  void InternalSaveValue(double* valptr);
  void InternalSaveValue(bool* valptr);
  void InternalSaveValue(void** valptr);
  void InternalSaveValue(int64** valptr) {
    InternalSaveValue(reinterpret_cast<void**>(valptr));
  }
 
  BaseObject* SafeRevAlloc(BaseObject* ptr);
 
  int* SafeRevAllocArray(int* ptr);
  int64* SafeRevAllocArray(int64* ptr);
  uint64* SafeRevAllocArray(uint64* ptr);
  double* SafeRevAllocArray(double* ptr);
  BaseObject** SafeRevAllocArray(BaseObject** ptr);
  IntVar** SafeRevAllocArray(IntVar** ptr);
  IntExpr** SafeRevAllocArray(IntExpr** ptr);
  Constraint** SafeRevAllocArray(Constraint** ptr);
  void* UnsafeRevAllocAux(void* ptr);
  template <class T>
  T* UnsafeRevAlloc(T* ptr) {
    return reinterpret_cast<T*>(
        UnsafeRevAllocAux(reinterpret_cast<void*>(ptr)));
  }
  void** UnsafeRevAllocArrayAux(void** ptr);
  template <class T>
  T** UnsafeRevAllocArray(T** ptr) {
    return reinterpret_cast<T**>(
        UnsafeRevAllocArrayAux(reinterpret_cast<void**>(ptr)));
  }
 
  void InitCachedIntConstants();
  void InitCachedConstraint();
 
  Search* TopLevelSearch() const { return searches_.at(1); }
  Search* ParentSearch() const {
    const size_t search_size = searches_.size();
    DCHECK_GT(search_size, 1);
    return searches_[search_size - 2];
  }
 
  std::string GetName(const PropagationBaseObject* object);
  void SetName(const PropagationBaseObject* object, const std::string& name);
 
  int GetNewIntVarIndex() { return num_int_vars_++; }
 
  bool IsADifference(IntExpr* expr, IntExpr** const left,
                     IntExpr** const right);
 
  const std::string name_;
  const ConstraintSolverParameters parameters_;
  absl::flat_hash_map<const PropagationBaseObject*, std::string>
      propagation_object_names_;
  absl::flat_hash_map<const PropagationBaseObject*, IntegerCastInfo>
      cast_information_;
  absl::flat_hash_set<const Constraint*> cast_constraints_;
  const std::string empty_name_;
  std::unique_ptr<Queue> queue_;
  std::unique_ptr<Trail> trail_;
  std::vector<Constraint*> constraints_list_;
  std::vector<Constraint*> additional_constraints_list_;
  std::vector<int> additional_constraints_parent_list_;
  SolverState state_;
  int64 branches_;
  int64 fails_;
  int64 decisions_;
  int64 demon_runs_[kNumPriorities];
  int64 neighbors_;
  int64 filtered_neighbors_;
  int64 accepted_neighbors_;
  OptimizationDirection optimization_direction_;
  std::unique_ptr<ClockTimer> timer_;
  std::vector<Search*> searches_;
  std::mt19937 random_;
  uint64 fail_stamp_;
  std::unique_ptr<Decision> balancing_decision_;
  std::function<void()> fail_intercept_;
  DemonProfiler* const demon_profiler_;
  bool use_fast_local_search_;
  LocalSearchProfiler* const local_search_profiler_;
  std::unique_ptr<Assignment> local_search_state_;
 
  enum { MIN_CACHED_INT_CONST = -8, MAX_CACHED_INT_CONST = 8 };
  IntVar* cached_constants_[MAX_CACHED_INT_CONST + 1 - MIN_CACHED_INT_CONST];
 
  Constraint* true_constraint_;
  Constraint* false_constraint_;
 
  std::unique_ptr<Decision> fail_decision_;
  int constraint_index_;
  int additional_constraint_index_;
  int num_int_vars_;
 
  std::unique_ptr<ModelCache> model_cache_;
  std::unique_ptr<PropagationMonitor> propagation_monitor_;
  PropagationMonitor* print_trace_;
  std::unique_ptr<LocalSearchMonitor> local_search_monitor_;
  int anonymous_variable_index_;
  bool should_fail_;
 
  DISALLOW_COPY_AND_ASSIGN(Solver);
};
 
std::ostream& operator<<(std::ostream& out, const Solver* const s);  
 
inline int64 Zero() { return 0; }
 
inline int64 One() { return 1; }
 
class BaseObject {
 public:
  BaseObject() {}
  virtual ~BaseObject() {}
  virtual std::string DebugString() const { return "BaseObject"; }
 
 private:
  DISALLOW_COPY_AND_ASSIGN(BaseObject);
};
 
std::ostream& operator<<(std::ostream& out, const BaseObject* o);  
 
class PropagationBaseObject : public BaseObject {
 public:
  explicit PropagationBaseObject(Solver* const s) : solver_(s) {}
  ~PropagationBaseObject() override {}
 
  std::string DebugString() const override {
    if (name().empty()) {
      return "PropagationBaseObject";
    } else {
      return absl::StrFormat("PropagationBaseObject: %s", name());
    }
  }
  Solver* solver() const { return solver_; }
 
  void FreezeQueue() { solver_->FreezeQueue(); }
 
  void UnfreezeQueue() { solver_->UnfreezeQueue(); }
 
  void EnqueueDelayedDemon(Demon* const d) { solver_->EnqueueDelayedDemon(d); }
  void EnqueueVar(Demon* const d) { solver_->EnqueueVar(d); }
  void ExecuteAll(const SimpleRevFIFO<Demon*>& demons);
  void EnqueueAll(const SimpleRevFIFO<Demon*>& demons);
 
#if !defined(SWIG)
  // This method sets a callback that will be called if a failure
  // happens during the propagation of the queue.
  void set_action_on_fail(Solver::Action a) {
    solver_->set_action_on_fail(std::move(a));
  }
#endif  // !defined(SWIG)
 
  void reset_action_on_fail() { solver_->reset_action_on_fail(); }
 
  void set_variable_to_clean_on_fail(IntVar* v) {
    solver_->set_variable_to_clean_on_fail(v);
  }
 
  virtual std::string name() const;
  void set_name(const std::string& name);
  bool HasName() const;
  virtual std::string BaseName() const;
 
 private:
  Solver* const solver_;
  DISALLOW_COPY_AND_ASSIGN(PropagationBaseObject);
};
 
class Decision : public BaseObject {
 public:
  Decision() {}
  ~Decision() override {}
 
  virtual void Apply(Solver* const s) = 0;
 
  virtual void Refute(Solver* const s) = 0;
 
  std::string DebugString() const override { return "Decision"; }
  virtual void Accept(DecisionVisitor* const visitor) const;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(Decision);
};
 
class DecisionVisitor : public BaseObject {
 public:
  DecisionVisitor() {}
  ~DecisionVisitor() override {}
  virtual void VisitSetVariableValue(IntVar* const var, int64 value);
  virtual void VisitSplitVariableDomain(IntVar* const var, int64 value,
                                        bool start_with_lower_half);
  virtual void VisitScheduleOrPostpone(IntervalVar* const var, int64 est);
  virtual void VisitScheduleOrExpedite(IntervalVar* const var, int64 est);
  virtual void VisitRankFirstInterval(SequenceVar* const sequence, int index);
  virtual void VisitRankLastInterval(SequenceVar* const sequence, int index);
  virtual void VisitUnknownDecision();
 
 private:
  DISALLOW_COPY_AND_ASSIGN(DecisionVisitor);
};
 
class DecisionBuilder : public BaseObject {
 public:
  DecisionBuilder() {}
  ~DecisionBuilder() override {}
  virtual Decision* Next(Solver* const s) = 0;
  std::string DebugString() const override;
#if !defined(SWIG)
  virtual void AppendMonitors(Solver* const solver,
                              std::vector<SearchMonitor*>* const extras);
  virtual void Accept(ModelVisitor* const visitor) const;
#endif
 
 private:
  DISALLOW_COPY_AND_ASSIGN(DecisionBuilder);
};
 
class Demon : public BaseObject {
 public:
  Demon() : stamp_(GG_ULONGLONG(0)) {}
  ~Demon() override {}
 
  virtual void Run(Solver* const s) = 0;
 
  virtual Solver::DemonPriority priority() const;
 
  std::string DebugString() const override;
 
  void inhibit(Solver* const s);
 
  void desinhibit(Solver* const s);
 
 private:
  friend class Queue;
  void set_stamp(int64 stamp) { stamp_ = stamp; }
  uint64 stamp() const { return stamp_; }
  uint64 stamp_;
  DISALLOW_COPY_AND_ASSIGN(Demon);
};
 
class ModelVisitor : public BaseObject {
 public:
  static const char kAbs[];
  static const char kAbsEqual[];
  static const char kAllDifferent[];
  static const char kAllowedAssignments[];
  static const char kAtMost[];
  static const char kIndexOf[];
  static const char kBetween[];
  static const char kConditionalExpr[];
  static const char kCircuit[];
  static const char kConvexPiecewise[];
  static const char kCountEqual[];
  static const char kCover[];
  static const char kCumulative[];
  static const char kDeviation[];
  static const char kDifference[];
  static const char kDisjunctive[];
  static const char kDistribute[];
  static const char kDivide[];
  static const char kDurationExpr[];
  static const char kElement[];
  static const char kElementEqual[];
  static const char kEndExpr[];
  static const char kEquality[];
  static const char kFalseConstraint[];
  static const char kGlobalCardinality[];
  static const char kGreater[];
  static const char kGreaterOrEqual[];
  static const char kIntegerVariable[];
  static const char kIntervalBinaryRelation[];
  static const char kIntervalDisjunction[];
  static const char kIntervalUnaryRelation[];
  static const char kIntervalVariable[];
  static const char kInversePermutation[];
  static const char kIsBetween[];
  static const char kIsDifferent[];
  static const char kIsEqual[];
  static const char kIsGreater[];
  static const char kIsGreaterOrEqual[];
  static const char kIsLess[];
  static const char kIsLessOrEqual[];
  static const char kIsMember[];
  static const char kLess[];
  static const char kLessOrEqual[];
  static const char kLexLess[];
  static const char kLinkExprVar[];
  static const char kMapDomain[];
  static const char kMax[];
  static const char kMaxEqual[];
  static const char kMember[];
  static const char kMin[];
  static const char kMinEqual[];
  static const char kModulo[];
  static const char kNoCycle[];
  static const char kNonEqual[];
  static const char kNotBetween[];
  static const char kNotMember[];
  static const char kNullIntersect[];
  static const char kOpposite[];
  static const char kPack[];
  static const char kPathCumul[];
  static const char kDelayedPathCumul[];
  static const char kPerformedExpr[];
  static const char kPower[];
  static const char kProduct[];
  static const char kScalProd[];
  static const char kScalProdEqual[];
  static const char kScalProdGreaterOrEqual[];
  static const char kScalProdLessOrEqual[];
  static const char kSemiContinuous[];
  static const char kSequenceVariable[];
  static const char kSortingConstraint[];
  static const char kSquare[];
  static const char kStartExpr[];
  static const char kSum[];
  static const char kSumEqual[];
  static const char kSumGreaterOrEqual[];
  static const char kSumLessOrEqual[];
  static const char kTrace[];
  static const char kTransition[];
  static const char kTrueConstraint[];
  static const char kVarBoundWatcher[];
  static const char kVarValueWatcher[];
 
  static const char kCountAssignedItemsExtension[];
  static const char kCountUsedBinsExtension[];
  static const char kInt64ToBoolExtension[];
  static const char kInt64ToInt64Extension[];
  static const char kObjectiveExtension[];
  static const char kSearchLimitExtension[];
  static const char kUsageEqualVariableExtension[];
 
  static const char kUsageLessConstantExtension[];
  static const char kVariableGroupExtension[];
  static const char kVariableUsageLessConstantExtension[];
  static const char kWeightedSumOfAssignedEqualVariableExtension[];
 
  static const char kActiveArgument[];
  static const char kAssumePathsArgument[];
  static const char kBranchesLimitArgument[];
  static const char kCapacityArgument[];
  static const char kCardsArgument[];
  static const char kCoefficientsArgument[];
  static const char kCountArgument[];
  static const char kCumulativeArgument[];
  static const char kCumulsArgument[];
  static const char kDemandsArgument[];
  static const char kDurationMaxArgument[];
  static const char kDurationMinArgument[];
  static const char kEarlyCostArgument[];
  static const char kEarlyDateArgument[];
  static const char kEndMaxArgument[];
  static const char kEndMinArgument[];
  static const char kEndsArgument[];
  static const char kExpressionArgument[];
  static const char kFailuresLimitArgument[];
  static const char kFinalStatesArgument[];
  static const char kFixedChargeArgument[];
  static const char kIndex2Argument[];
  static const char kIndexArgument[];
  static const char kInitialState[];
  static const char kIntervalArgument[];
  static const char kIntervalsArgument[];
  static const char kLateCostArgument[];
  static const char kLateDateArgument[];
  static const char kLeftArgument[];
  static const char kMaxArgument[];
  static const char kMaximizeArgument[];
  static const char kMinArgument[];
  static const char kModuloArgument[];
  static const char kNextsArgument[];
  static const char kOptionalArgument[];
  static const char kPartialArgument[];
  static const char kPositionXArgument[];
  static const char kPositionYArgument[];
  static const char kRangeArgument[];
  static const char kRelationArgument[];
  static const char kRightArgument[];
  static const char kSequenceArgument[];
  static const char kSequencesArgument[];
  static const char kSizeArgument[];
  static const char kSizeXArgument[];
  static const char kSizeYArgument[];
  static const char kSmartTimeCheckArgument[];
  static const char kSolutionLimitArgument[];
  static const char kStartMaxArgument[];
  static const char kStartMinArgument[];
  static const char kStartsArgument[];
  static const char kStepArgument[];
  static const char kTargetArgument[];
  static const char kTimeLimitArgument[];
  static const char kTransitsArgument[];
  static const char kTuplesArgument[];
  static const char kValueArgument[];
  static const char kValuesArgument[];
  static const char kVariableArgument[];
  static const char kVarsArgument[];
  static const char kEvaluatorArgument[];
 
  static const char kMirrorOperation[];
  static const char kRelaxedMaxOperation[];
  static const char kRelaxedMinOperation[];
  static const char kSumOperation[];
  static const char kDifferenceOperation[];
  static const char kProductOperation[];
  static const char kStartSyncOnStartOperation[];
  static const char kStartSyncOnEndOperation[];
  static const char kTraceOperation[];
 
  ~ModelVisitor() override;
 
 
  virtual void BeginVisitModel(const std::string& type_name);
  virtual void EndVisitModel(const std::string& type_name);
  virtual void BeginVisitConstraint(const std::string& type_name,
                                    const Constraint* const constraint);
  virtual void EndVisitConstraint(const std::string& type_name,
                                  const Constraint* const constraint);
  virtual void BeginVisitExtension(const std::string& type);
  virtual void EndVisitExtension(const std::string& type);
  virtual void BeginVisitIntegerExpression(const std::string& type_name,
                                           const IntExpr* const expr);
  virtual void EndVisitIntegerExpression(const std::string& type_name,
                                         const IntExpr* const expr);
  virtual void VisitIntegerVariable(const IntVar* const variable,
                                    IntExpr* const delegate);
  virtual void VisitIntegerVariable(const IntVar* const variable,
                                    const std::string& operation, int64 value,
                                    IntVar* const delegate);
  virtual void VisitIntervalVariable(const IntervalVar* const variable,
                                     const std::string& operation, int64 value,
                                     IntervalVar* const delegate);
  virtual void VisitSequenceVariable(const SequenceVar* const variable);
 
  virtual void VisitIntegerArgument(const std::string& arg_name, int64 value);
  virtual void VisitIntegerArrayArgument(const std::string& arg_name,
                                         const std::vector<int64>& values);
  virtual void VisitIntegerMatrixArgument(const std::string& arg_name,
                                          const IntTupleSet& tuples);
 
  virtual void VisitIntegerExpressionArgument(const std::string& arg_name,
                                              IntExpr* const argument);
 
  virtual void VisitIntegerVariableArrayArgument(
      const std::string& arg_name, const std::vector<IntVar*>& arguments);
 
  virtual void VisitIntervalArgument(const std::string& arg_name,
                                     IntervalVar* const argument);
 
  virtual void VisitIntervalArrayArgument(
      const std::string& arg_name, const std::vector<IntervalVar*>& arguments);
  virtual void VisitSequenceArgument(const std::string& arg_name,
                                     SequenceVar* const argument);
 
  virtual void VisitSequenceArrayArgument(
      const std::string& arg_name, const std::vector<SequenceVar*>& arguments);
#if !defined(SWIG)
  virtual void VisitIntegerVariableEvaluatorArgument(
      const std::string& arg_name, const Solver::Int64ToIntVar& arguments);
 
  void VisitInt64ToBoolExtension(Solver::IndexFilter1 filter, int64 index_min,
                                 int64 index_max);
  void VisitInt64ToInt64Extension(const Solver::IndexEvaluator1& eval,
                                  int64 index_min, int64 index_max);
  void VisitInt64ToInt64AsArray(const Solver::IndexEvaluator1& eval,
                                const std::string& arg_name, int64 index_max);
#endif  // #if !defined(SWIG)
};
 
class Constraint : public PropagationBaseObject {
 public:
  explicit Constraint(Solver* const solver) : PropagationBaseObject(solver) {}
  ~Constraint() override {}
 
  virtual void Post() = 0;
 
  virtual void InitialPropagate() = 0;
  std::string DebugString() const override;
 
  void PostAndPropagate();
 
  virtual void Accept(ModelVisitor* const visitor) const;
 
  bool IsCastConstraint() const;
 
  virtual IntVar* Var();
 
 private:
  DISALLOW_COPY_AND_ASSIGN(Constraint);
};
 
class CastConstraint : public Constraint {
 public:
  CastConstraint(Solver* const solver, IntVar* const target_var)
      : Constraint(solver), target_var_(target_var) {
    CHECK(target_var != nullptr);
  }
  ~CastConstraint() override {}
 
  IntVar* target_var() const { return target_var_; }
 
 protected:
  IntVar* const target_var_;
};
 
class SearchMonitor : public BaseObject {
 public:
  static const int kNoProgress = -1;
 
  explicit SearchMonitor(Solver* const s) : solver_(s) {}
  ~SearchMonitor() override {}
  virtual void EnterSearch();
 
  virtual void RestartSearch();
 
  virtual void ExitSearch();
 
  virtual void BeginNextDecision(DecisionBuilder* const b);
 
  virtual void EndNextDecision(DecisionBuilder* const b, Decision* const d);
 
  virtual void ApplyDecision(Decision* const d);
 
  virtual void RefuteDecision(Decision* const d);
 
  virtual void AfterDecision(Decision* const d, bool apply);
 
  virtual void BeginFail();
 
  virtual void EndFail();
 
  virtual void BeginInitialPropagation();
 
  virtual void EndInitialPropagation();
 
  virtual bool AcceptSolution();
 
  virtual bool AtSolution();
 
  virtual void NoMoreSolutions();
 
  virtual bool LocalOptimum();
 
  virtual bool AcceptDelta(Assignment* delta, Assignment* deltadelta);
 
  virtual void AcceptNeighbor();
 
  virtual void AcceptUncheckedNeighbor();
 
  virtual bool IsUncheckedSolutionLimitReached() { return false; }
 
  Solver* solver() const { return solver_; }
 
  virtual void PeriodicCheck();
 
  virtual int ProgressPercent() { return kNoProgress; }
 
  virtual void Accept(ModelVisitor* const visitor) const;
 
  virtual void Install();
 
 private:
  Solver* const solver_;
  DISALLOW_COPY_AND_ASSIGN(SearchMonitor);
};
 
template <class T>
class Rev {
 public:
  explicit Rev(const T& val) : stamp_(0), value_(val) {}
 
  const T& Value() const { return value_; }
 
  void SetValue(Solver* const s, const T& val) {
    if (val != value_) {
      if (stamp_ < s->stamp()) {
        s->SaveValue(&value_);
        stamp_ = s->stamp();
      }
      value_ = val;
    }
  }
 
 private:
  uint64 stamp_;
  T value_;
};
 
template <class T>
class NumericalRev : public Rev<T> {
 public:
  explicit NumericalRev(const T& val) : Rev<T>(val) {}
 
  void Add(Solver* const s, const T& to_add) {
    this->SetValue(s, this->Value() + to_add);
  }
 
  void Incr(Solver* const s) { Add(s, 1); }
 
  void Decr(Solver* const s) { Add(s, -1); }
};
 
template <class T>
class RevArray {
 public:
  RevArray(int size, const T& val)
      : stamps_(new uint64[size]), values_(new T[size]), size_(size) {
    for (int i = 0; i < size; ++i) {
      stamps_[i] = 0;
      values_[i] = val;
    }
  }
 
  ~RevArray() {}
 
  int64 size() const { return size_; }
 
  const T& Value(int index) const { return values_[index]; }
 
#if !defined(SWIG)
  const T& operator[](int index) const { return values_[index]; }
#endif
 
  void SetValue(Solver* const s, int index, const T& val) {
    DCHECK_LT(index, size_);
    if (val != values_[index]) {
      if (stamps_[index] < s->stamp()) {
        s->SaveValue(&values_[index]);
        stamps_[index] = s->stamp();
      }
      values_[index] = val;
    }
  }
 
 private:
  std::unique_ptr<uint64[]> stamps_;
  std::unique_ptr<T[]> values_;
  const int size_;
};
 
template <class T>
class NumericalRevArray : public RevArray<T> {
 public:
  NumericalRevArray(int size, const T& val) : RevArray<T>(size, val) {}
 
  void Add(Solver* const s, int index, const T& to_add) {
    this->SetValue(s, index, this->Value(index) + to_add);
  }
 
  void Incr(Solver* const s, int index) { Add(s, index, 1); }
 
  void Decr(Solver* const s, int index) { Add(s, index, -1); }
};
 
class IntExpr : public PropagationBaseObject {
 public:
  explicit IntExpr(Solver* const s) : PropagationBaseObject(s) {}
  ~IntExpr() override {}
 
  virtual int64 Min() const = 0;
  virtual void SetMin(int64 m) = 0;
  virtual int64 Max() const = 0;
  virtual void SetMax(int64 m) = 0;
 
  virtual void Range(int64* l, int64* u) {
    *l = Min();
    *u = Max();
  }
  virtual void SetRange(int64 l, int64 u) {
    SetMin(l);
    SetMax(u);
  }
 
  virtual void SetValue(int64 v) { SetRange(v, v); }
 
  virtual bool Bound() const { return (Min() == Max()); }
 
  virtual bool IsVar() const { return false; }
 
  virtual IntVar* Var() = 0;
 
  IntVar* VarWithName(const std::string& name);
 
  virtual void WhenRange(Demon* d) = 0;
  void WhenRange(Solver::Closure closure) {
    WhenRange(solver()->MakeClosureDemon(std::move(closure)));
  }
 
#if !defined(SWIG)
  void WhenRange(Solver::Action action) {
    WhenRange(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual void Accept(ModelVisitor* const visitor) const;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(IntExpr);
};
 
 
 
 
class IntVarIterator : public BaseObject {
 public:
  ~IntVarIterator() override {}
 
  virtual void Init() = 0;
 
  virtual bool Ok() const = 0;
 
  virtual int64 Value() const = 0;
 
  virtual void Next() = 0;
 
  std::string DebugString() const override { return "IntVar::Iterator"; }
};
 
#ifndef SWIG
class InitAndGetValues {
 public:
  explicit InitAndGetValues(IntVarIterator* it)
      : it_(it), begin_was_called_(false) {
    it_->Init();
  }
  struct Iterator;
  Iterator begin() {
    if (DEBUG_MODE) {
      DCHECK(!begin_was_called_);
      begin_was_called_ = true;
    }
    return Iterator::Begin(it_);
  }
  Iterator end() { return Iterator::End(it_); }
 
  struct Iterator {
    static Iterator Begin(IntVarIterator* it) {
      return Iterator(it, /*is_end=*/false);
    }
    static Iterator End(IntVarIterator* it) {
      return Iterator(it, /*is_end=*/true);
    }
 
    int64 operator*() const {
      DCHECK(it_->Ok());
      return it_->Value();
    }
    Iterator& operator++() {
      DCHECK(it_->Ok());
      it_->Next();
      return *this;
    }
    bool operator!=(const Iterator& other) const {
      DCHECK(other.it_ == it_);
      DCHECK(other.is_end_);
      return it_->Ok();
    }
 
   private:
    Iterator(IntVarIterator* it, bool is_end) : it_(it), is_end_(is_end) {}
 
    IntVarIterator* const it_;
    const bool is_end_;
  };
 
 private:
  IntVarIterator* const it_;
  bool begin_was_called_;
};
#endif  // SWIG
 
class IntVar : public IntExpr {
 public:
  explicit IntVar(Solver* const s);
  IntVar(Solver* const s, const std::string& name);
  ~IntVar() override {}
 
  bool IsVar() const override { return true; }
  IntVar* Var() override { return this; }
 
  virtual int64 Value() const = 0;
 
  virtual void RemoveValue(int64 v) = 0;
 
  virtual void RemoveInterval(int64 l, int64 u) = 0;
 
  virtual void RemoveValues(const std::vector<int64>& values);
 
  virtual void SetValues(const std::vector<int64>& values);
 
  virtual void WhenBound(Demon* d) = 0;
  void WhenBound(Solver::Closure closure) {
    WhenBound(solver()->MakeClosureDemon(std::move(closure)));
  }
 
#if !defined(SWIG)
  void WhenBound(Solver::Action action) {
    WhenBound(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual void WhenDomain(Demon* d) = 0;
  void WhenDomain(Solver::Closure closure) {
    WhenDomain(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenDomain(Solver::Action action) {
    WhenDomain(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual uint64 Size() const = 0;
 
  virtual bool Contains(int64 v) const = 0;
 
  virtual IntVarIterator* MakeHoleIterator(bool reversible) const = 0;
 
  virtual IntVarIterator* MakeDomainIterator(bool reversible) const = 0;
 
  virtual int64 OldMin() const = 0;
 
  virtual int64 OldMax() const = 0;
 
  virtual int VarType() const;
 
  void Accept(ModelVisitor* const visitor) const override;
 
  virtual IntVar* IsEqual(int64 constant) = 0;
  virtual IntVar* IsDifferent(int64 constant) = 0;
  virtual IntVar* IsGreaterOrEqual(int64 constant) = 0;
  virtual IntVar* IsLessOrEqual(int64 constant) = 0;
 
  int index() const { return index_; }
 
 private:
  const int index_;
  DISALLOW_COPY_AND_ASSIGN(IntVar);
};
 
class SolutionCollector : public SearchMonitor {
 public:
  SolutionCollector(Solver* const solver, const Assignment* assignment);
  explicit SolutionCollector(Solver* const solver);
  ~SolutionCollector() override;
  std::string DebugString() const override { return "SolutionCollector"; }
 
  void Add(IntVar* const var);
  void Add(const std::vector<IntVar*>& vars);
  void Add(IntervalVar* const var);
  void Add(const std::vector<IntervalVar*>& vars);
  void Add(SequenceVar* const var);
  void Add(const std::vector<SequenceVar*>& vars);
  void AddObjective(IntVar* const objective);
 
  void EnterSearch() override;
 
  int solution_count() const;
 
  Assignment* solution(int n) const;
 
  int64 wall_time(int n) const;
 
  int64 branches(int n) const;
 
  int64 failures(int n) const;
 
  int64 objective_value(int n) const;
 
  int64 Value(int n, IntVar* const var) const;
 
  int64 StartValue(int n, IntervalVar* const var) const;
 
  int64 EndValue(int n, IntervalVar* const var) const;
 
  int64 DurationValue(int n, IntervalVar* const var) const;
 
  int64 PerformedValue(int n, IntervalVar* const var) const;
 
  const std::vector<int>& ForwardSequence(int n, SequenceVar* const var) const;
  const std::vector<int>& BackwardSequence(int n, SequenceVar* const var) const;
  const std::vector<int>& Unperformed(int n, SequenceVar* const var) const;
 
 protected:
  struct SolutionData {
    Assignment* solution;
    int64 time;
    int64 branches;
    int64 failures;
    int64 objective_value;
    bool operator<(const SolutionData& other) const {
      return std::tie(solution, time, branches, failures, objective_value) <
             std::tie(other.solution, other.time, other.branches,
                      other.failures, other.objective_value);
    }
  };
 
  void PushSolution();
  void Push(const SolutionData& data) { solution_data_.push_back(data); }
  void PopSolution();
  SolutionData BuildSolutionDataForCurrentState();
  void FreeSolution(Assignment* solution);
  void check_index(int n) const;
 
  std::unique_ptr<Assignment> prototype_;
  std::vector<SolutionData> solution_data_;
  std::vector<Assignment*> recycle_solutions_;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(SolutionCollector);
};
 
// TODO(user): Refactor this into an Objective class:
//   - print methods for AtNode and AtSolution.
//   - support for weighted objective and lexicographical objective.
 
class OptimizeVar : public SearchMonitor {
 public:
  OptimizeVar(Solver* const s, bool maximize, IntVar* const a, int64 step);
  ~OptimizeVar() override;
 
  int64 best() const { return best_; }
 
  IntVar* Var() const { return var_; }
  bool AcceptDelta(Assignment* delta, Assignment* deltadelta) override;
  void EnterSearch() override;
  void BeginNextDecision(DecisionBuilder* const db) override;
  void RefuteDecision(Decision* const d) override;
  bool AtSolution() override;
  bool AcceptSolution() override;
  virtual std::string Print() const;
  std::string DebugString() const override;
  void Accept(ModelVisitor* const visitor) const override;
 
  void ApplyBound();
 
 protected:
  IntVar* const var_;
  int64 step_;
  int64 best_;
  bool maximize_;
  bool found_initial_solution_;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(OptimizeVar);
};
 
class SearchLimit : public SearchMonitor {
 public:
  explicit SearchLimit(Solver* const s) : SearchMonitor(s), crossed_(false) {}
  ~SearchLimit() override;
 
  bool crossed() const { return crossed_; }
 
  virtual bool Check() = 0;
 
  virtual void Init() = 0;
 
  virtual void Copy(const SearchLimit* const limit) = 0;
 
  virtual SearchLimit* MakeClone() const = 0;
 
  void EnterSearch() override;
  void BeginNextDecision(DecisionBuilder* const b) override;
  void PeriodicCheck() override;
  void RefuteDecision(Decision* const d) override;
  std::string DebugString() const override {
    return absl::StrFormat("SearchLimit(crossed = %i)", crossed_);
  }
 
 private:
  void TopPeriodicCheck();
 
  bool crossed_;
  DISALLOW_COPY_AND_ASSIGN(SearchLimit);
};
 
class RegularLimit : public SearchLimit {
 public:
  RegularLimit(Solver* const s, int64 time, int64 branches, int64 failures,
               int64 solutions, bool smart_time_check, bool cumulative);
  ~RegularLimit() override;
  void Copy(const SearchLimit* const limit) override;
  SearchLimit* MakeClone() const override;
  RegularLimit* MakeIdenticalClone() const;
  bool Check() override;
  void Init() override;
  void ExitSearch() override;
  void UpdateLimits(int64 time, int64 branches, int64 failures,
                    int64 solutions);
  absl::Duration duration_limit() const { return duration_limit_; }
  int64 wall_time() const {
    return duration_limit_ == absl::InfiniteDuration()
               ? kint64max
               : absl::ToInt64Milliseconds(duration_limit());
  }
  int64 branches() const { return branches_; }
  int64 failures() const { return failures_; }
  int64 solutions() const { return solutions_; }
  bool IsUncheckedSolutionLimitReached() override;
  int ProgressPercent() override;
  std::string DebugString() const override;
 
  absl::Time AbsoluteSolverDeadline() const {
    return solver_time_at_limit_start_ + duration_limit_;
  }
 
  void Accept(ModelVisitor* const visitor) const override;
 
 private:
  bool CheckTime();
  absl::Duration TimeElapsed();
  static int64 GetPercent(int64 value, int64 offset, int64 total) {
    return (total > 0 && total < kint64max) ? 100 * (value - offset) / total
                                            : -1;
  }
 
  absl::Duration duration_limit_;
  absl::Time solver_time_at_limit_start_;
  absl::Duration last_time_elapsed_;
  int64 check_count_;
  int64 next_check_;
  bool smart_time_check_;
  int64 branches_;
  int64 branches_offset_;
  int64 failures_;
  int64 failures_offset_;
  int64 solutions_;
  int64 solutions_offset_;
  bool cumulative_;
};
 
class IntervalVar : public PropagationBaseObject {
 public:
  static const int64 kMinValidValue;
  static const int64 kMaxValidValue;
  IntervalVar(Solver* const solver, const std::string& name)
      : PropagationBaseObject(solver) {
    set_name(name);
  }
  ~IntervalVar() override {}
 
  virtual int64 StartMin() const = 0;
  virtual int64 StartMax() const = 0;
  virtual void SetStartMin(int64 m) = 0;
  virtual void SetStartMax(int64 m) = 0;
  virtual void SetStartRange(int64 mi, int64 ma) = 0;
  virtual int64 OldStartMin() const = 0;
  virtual int64 OldStartMax() const = 0;
  virtual void WhenStartRange(Demon* const d) = 0;
  void WhenStartRange(Solver::Closure closure) {
    WhenStartRange(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenStartRange(Solver::Action action) {
    WhenStartRange(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
  virtual void WhenStartBound(Demon* const d) = 0;
  void WhenStartBound(Solver::Closure closure) {
    WhenStartBound(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenStartBound(Solver::Action action) {
    WhenStartBound(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual int64 DurationMin() const = 0;
  virtual int64 DurationMax() const = 0;
  virtual void SetDurationMin(int64 m) = 0;
  virtual void SetDurationMax(int64 m) = 0;
  virtual void SetDurationRange(int64 mi, int64 ma) = 0;
  virtual int64 OldDurationMin() const = 0;
  virtual int64 OldDurationMax() const = 0;
  virtual void WhenDurationRange(Demon* const d) = 0;
  void WhenDurationRange(Solver::Closure closure) {
    WhenDurationRange(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenDurationRange(Solver::Action action) {
    WhenDurationRange(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
  virtual void WhenDurationBound(Demon* const d) = 0;
  void WhenDurationBound(Solver::Closure closure) {
    WhenDurationBound(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenDurationBound(Solver::Action action) {
    WhenDurationBound(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual int64 EndMin() const = 0;
  virtual int64 EndMax() const = 0;
  virtual void SetEndMin(int64 m) = 0;
  virtual void SetEndMax(int64 m) = 0;
  virtual void SetEndRange(int64 mi, int64 ma) = 0;
  virtual int64 OldEndMin() const = 0;
  virtual int64 OldEndMax() const = 0;
  virtual void WhenEndRange(Demon* const d) = 0;
  void WhenEndRange(Solver::Closure closure) {
    WhenEndRange(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenEndRange(Solver::Action action) {
    WhenEndRange(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
  virtual void WhenEndBound(Demon* const d) = 0;
  void WhenEndBound(Solver::Closure closure) {
    WhenEndBound(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenEndBound(Solver::Action action) {
    WhenEndBound(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual bool MustBePerformed() const = 0;
  virtual bool MayBePerformed() const = 0;
  bool CannotBePerformed() const { return !MayBePerformed(); }
  bool IsPerformedBound() const {
    return MustBePerformed() || !MayBePerformed();
  }
  virtual void SetPerformed(bool val) = 0;
  virtual bool WasPerformedBound() const = 0;
  virtual void WhenPerformedBound(Demon* const d) = 0;
  void WhenPerformedBound(Solver::Closure closure) {
    WhenPerformedBound(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenPerformedBound(Solver::Action action) {
    WhenPerformedBound(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  void WhenAnything(Demon* const d);
  void WhenAnything(Solver::Closure closure) {
    WhenAnything(solver()->MakeClosureDemon(std::move(closure)));
  }
#if !defined(SWIG)
  void WhenAnything(Solver::Action action) {
    WhenAnything(solver()->MakeActionDemon(std::move(action)));
  }
#endif  // SWIG
 
  virtual IntExpr* StartExpr() = 0;
  virtual IntExpr* DurationExpr() = 0;
  virtual IntExpr* EndExpr() = 0;
  virtual IntExpr* PerformedExpr() = 0;
  virtual IntExpr* SafeStartExpr(int64 unperformed_value) = 0;
  virtual IntExpr* SafeDurationExpr(int64 unperformed_value) = 0;
  virtual IntExpr* SafeEndExpr(int64 unperformed_value) = 0;
 
  virtual void Accept(ModelVisitor* const visitor) const = 0;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(IntervalVar);
};
 
class SequenceVar : public PropagationBaseObject {
 public:
  SequenceVar(Solver* const s, const std::vector<IntervalVar*>& intervals,
              const std::vector<IntVar*>& nexts, const std::string& name);
 
  ~SequenceVar() override;
 
  std::string DebugString() const override;
 
#if !defined(SWIG)
  void DurationRange(int64* const dmin, int64* const dmax) const;
 
  void HorizonRange(int64* const hmin, int64* const hmax) const;
 
  void ActiveHorizonRange(int64* const hmin, int64* const hmax) const;
 
  void ComputeStatistics(int* const ranked, int* const not_ranked,
                         int* const unperformed) const;
#endif  // !defined(SWIG)
 
  void RankFirst(int index);
 
  void RankNotFirst(int index);
 
  void RankLast(int index);
 
  void RankNotLast(int index);
 
  void ComputePossibleFirstsAndLasts(std::vector<int>* const possible_firsts,
                                     std::vector<int>* const possible_lasts);
 
  void RankSequence(const std::vector<int>& rank_first,
                    const std::vector<int>& rank_last,
                    const std::vector<int>& unperformed);
 
  void FillSequence(std::vector<int>* const rank_first,
                    std::vector<int>* const rank_last,
                    std::vector<int>* const unperformed) const;
 
  IntervalVar* Interval(int index) const;
 
  IntVar* Next(int index) const;
 
  int64 size() const { return intervals_.size(); }
 
  virtual void Accept(ModelVisitor* const visitor) const;
 
 private:
  int ComputeForwardFrontier();
  int ComputeBackwardFrontier();
  void UpdatePrevious() const;
 
  const std::vector<IntervalVar*> intervals_;
  const std::vector<IntVar*> nexts_;
  mutable std::vector<int> previous_;
};
 
class AssignmentElement {
 public:
  AssignmentElement() : activated_(true) {}
 
  void Activate() { activated_ = true; }
  void Deactivate() { activated_ = false; }
  bool Activated() const { return activated_; }
 
 private:
  bool activated_;
};
 
class IntVarElement : public AssignmentElement {
 public:
  IntVarElement();
  explicit IntVarElement(IntVar* const var);
  void Reset(IntVar* const var);
  IntVarElement* Clone();
  void Copy(const IntVarElement& element);
  IntVar* Var() const { return var_; }
  void Store() {
    min_ = var_->Min();
    max_ = var_->Max();
  }
  void Restore() {
    if (var_ != nullptr) {
      var_->SetRange(min_, max_);
    }
  }
  void LoadFromProto(const IntVarAssignment& int_var_assignment_proto);
  void WriteToProto(IntVarAssignment* int_var_assignment_proto) const;
 
  int64 Min() const { return min_; }
  void SetMin(int64 m) { min_ = m; }
  int64 Max() const { return max_; }
  void SetMax(int64 m) { max_ = m; }
  int64 Value() const {
    DCHECK_EQ(min_, max_);
    // Get the value from an unbound int var assignment element.
    return min_;
  }
  bool Bound() const { return (max_ == min_); }
  void SetRange(int64 l, int64 u) {
    min_ = l;
    max_ = u;
  }
  void SetValue(int64 v) {
    min_ = v;
    max_ = v;
  }
  std::string DebugString() const;
 
  bool operator==(const IntVarElement& element) const;
  bool operator!=(const IntVarElement& element) const {
    return !(*this == element);
  }
 
 private:
  IntVar* var_;
  int64 min_;
  int64 max_;
};
 
class IntervalVarElement : public AssignmentElement {
 public:
  IntervalVarElement();
  explicit IntervalVarElement(IntervalVar* const var);
  void Reset(IntervalVar* const var);
  IntervalVarElement* Clone();
  void Copy(const IntervalVarElement& element);
  IntervalVar* Var() const { return var_; }
  void Store();
  void Restore();
  void LoadFromProto(
      const IntervalVarAssignment& interval_var_assignment_proto);
  void WriteToProto(IntervalVarAssignment* interval_var_assignment_proto) const;
 
  int64 StartMin() const { return start_min_; }
  int64 StartMax() const { return start_max_; }
  int64 StartValue() const {
    CHECK_EQ(start_max_, start_min_);
    return start_max_;
  }
  int64 DurationMin() const { return duration_min_; }
  int64 DurationMax() const { return duration_max_; }
  int64 DurationValue() const {
    CHECK_EQ(duration_max_, duration_min_);
    return duration_max_;
  }
  int64 EndMin() const { return end_min_; }
  int64 EndMax() const { return end_max_; }
  int64 EndValue() const {
    CHECK_EQ(end_max_, end_min_);
    return end_max_;
  }
  int64 PerformedMin() const { return performed_min_; }
  int64 PerformedMax() const { return performed_max_; }
  int64 PerformedValue() const {
    CHECK_EQ(performed_max_, performed_min_);
    return performed_max_;
  }
  void SetStartMin(int64 m) { start_min_ = m; }
  void SetStartMax(int64 m) { start_max_ = m; }
  void SetStartRange(int64 mi, int64 ma) {
    start_min_ = mi;
    start_max_ = ma;
  }
  void SetStartValue(int64 v) {
    start_min_ = v;
    start_max_ = v;
  }
  void SetDurationMin(int64 m) { duration_min_ = m; }
  void SetDurationMax(int64 m) { duration_max_ = m; }
  void SetDurationRange(int64 mi, int64 ma) {
    duration_min_ = mi;
    duration_max_ = ma;
  }
  void SetDurationValue(int64 v) {
    duration_min_ = v;
    duration_max_ = v;
  }
  void SetEndMin(int64 m) { end_min_ = m; }
  void SetEndMax(int64 m) { end_max_ = m; }
  void SetEndRange(int64 mi, int64 ma) {
    end_min_ = mi;
    end_max_ = ma;
  }
  void SetEndValue(int64 v) {
    end_min_ = v;
    end_max_ = v;
  }
  void SetPerformedMin(int64 m) { performed_min_ = m; }
  void SetPerformedMax(int64 m) { performed_max_ = m; }
  void SetPerformedRange(int64 mi, int64 ma) {
    performed_min_ = mi;
    performed_max_ = ma;
  }
  void SetPerformedValue(int64 v) {
    performed_min_ = v;
    performed_max_ = v;
  }
  bool Bound() const {
    return (start_min_ == start_max_ && duration_min_ == duration_max_ &&
            end_min_ == end_max_ && performed_min_ == performed_max_);
  }
  std::string DebugString() const;
  bool operator==(const IntervalVarElement& element) const;
  bool operator!=(const IntervalVarElement& element) const {
    return !(*this == element);
  }
 
 private:
  int64 start_min_;
  int64 start_max_;
  int64 duration_min_;
  int64 duration_max_;
  int64 end_min_;
  int64 end_max_;
  int64 performed_min_;
  int64 performed_max_;
  IntervalVar* var_;
};
 
class SequenceVarElement : public AssignmentElement {
 public:
  SequenceVarElement();
  explicit SequenceVarElement(SequenceVar* const var);
  void Reset(SequenceVar* const var);
  SequenceVarElement* Clone();
  void Copy(const SequenceVarElement& element);
  SequenceVar* Var() const { return var_; }
  void Store();
  void Restore();
  void LoadFromProto(
      const SequenceVarAssignment& sequence_var_assignment_proto);
  void WriteToProto(SequenceVarAssignment* sequence_var_assignment_proto) const;
 
  const std::vector<int>& ForwardSequence() const;
  const std::vector<int>& BackwardSequence() const;
  const std::vector<int>& Unperformed() const;
  void SetSequence(const std::vector<int>& forward_sequence,
                   const std::vector<int>& backward_sequence,
                   const std::vector<int>& unperformed);
  void SetForwardSequence(const std::vector<int>& forward_sequence);
  void SetBackwardSequence(const std::vector<int>& backward_sequence);
  void SetUnperformed(const std::vector<int>& unperformed);
  bool Bound() const {
    return forward_sequence_.size() + unperformed_.size() == var_->size();
  }
 
  std::string DebugString() const;
 
  bool operator==(const SequenceVarElement& element) const;
  bool operator!=(const SequenceVarElement& element) const {
    return !(*this == element);
  }
 
 private:
  bool CheckClassInvariants();
 
  SequenceVar* var_;
  std::vector<int> forward_sequence_;
  std::vector<int> backward_sequence_;
  std::vector<int> unperformed_;
};
 
template <class V, class E>
class AssignmentContainer {
 public:
  AssignmentContainer() {}
  E* Add(V* var) {
    CHECK(var != nullptr);
    int index = -1;
    if (!Find(var, &index)) {
      return FastAdd(var);
    } else {
      return &elements_[index];
    }
  }
  E* FastAdd(V* var) {
    DCHECK(var != nullptr);
    elements_.emplace_back(var);
    return &elements_.back();
  }
  E* AddAtPosition(V* var, int position) {
    elements_[position].Reset(var);
    return &elements_[position];
  }
  void Clear() {
    elements_.clear();
    if (!elements_map_.empty()) {  
      elements_map_.clear();
    }
  }
  void Resize(size_t size) { elements_.resize(size); }
  bool Empty() const { return elements_.empty(); }
  void CopyIntersection(const AssignmentContainer<V, E>& container) {
    for (int i = 0; i < container.elements_.size(); ++i) {
      const E& element = container.elements_[i];
      const V* const var = element.Var();
      int index = -1;
      if (i < elements_.size() && elements_[i].Var() == var) {
        index = i;
      } else if (!Find(var, &index)) {
        continue;
      }
      DCHECK_GE(index, 0);
      E* const local_element = &elements_[index];
      local_element->Copy(element);
      if (element.Activated()) {
        local_element->Activate();
      } else {
        local_element->Deactivate();
      }
    }
  }
  void Copy(const AssignmentContainer<V, E>& container) {
    Clear();
    for (int i = 0; i < container.elements_.size(); ++i) {
      const E& element = container.elements_[i];
      FastAdd(element.Var())->Copy(element);
    }
  }
  bool Contains(const V* const var) const {
    int index;
    return Find(var, &index);
  }
  E* MutableElement(const V* const var) {
    E* const element = MutableElementOrNull(var);
    DCHECK(element != nullptr)
        << "Unknown variable " << var->DebugString() << " in solution";
    return element;
  }
  E* MutableElementOrNull(const V* const var) {
    int index = -1;
    if (Find(var, &index)) {
      return MutableElement(index);
    }
    return nullptr;
  }
  const E& Element(const V* const var) const {
    const E* const element = ElementPtrOrNull(var);
    DCHECK(element != nullptr)
        << "Unknown variable " << var->DebugString() << " in solution";
    return *element;
  }
  const E* ElementPtrOrNull(const V* const var) const {
    int index = -1;
    if (Find(var, &index)) {
      return &Element(index);
    }
    return nullptr;
  }
  const std::vector<E>& elements() const { return elements_; }
  E* MutableElement(int index) { return &elements_[index]; }
  const E& Element(int index) const { return elements_[index]; }
  int Size() const { return elements_.size(); }
  void Store() {
    for (E& element : elements_) {
      element.Store();
    }
  }
  void Restore() {
    for (E& element : elements_) {
      if (element.Activated()) {
        element.Restore();
      }
    }
  }
  bool AreAllElementsBound() const {
    for (const E& element : elements_) {
      if (!element.Bound()) return false;
    }
    return true;
  }
 
  bool operator==(const AssignmentContainer<V, E>& container) const {
    if (Size() != container.Size()) {
      return false;
    }
    EnsureMapIsUpToDate();
    for (const E& element : container.elements_) {
      const int position =
          gtl::FindWithDefault(elements_map_, element.Var(), -1);
      if (position < 0 || elements_[position] != element) {
        return false;
      }
    }
    return true;
  }
  bool operator!=(const AssignmentContainer<V, E>& container) const {
    return !(*this == container);
  }
 
 private:
  void EnsureMapIsUpToDate() const {
    absl::flat_hash_map<const V*, int>* map =
        const_cast<absl::flat_hash_map<const V*, int>*>(&elements_map_);
    for (int i = map->size(); i < elements_.size(); ++i) {
      (*map)[elements_[i].Var()] = i;
    }
  }
  bool Find(const V* const var, int* index) const {
    const size_t kMaxSizeForLinearAccess = 11;
    if (Size() <= kMaxSizeForLinearAccess) {
      for (int i = 0; i < elements_.size(); ++i) {
        if (var == elements_[i].Var()) {
          *index = i;
          return true;
        }
      }
      return false;
    } else {
      EnsureMapIsUpToDate();
      DCHECK_EQ(elements_map_.size(), elements_.size());
      return gtl::FindCopy(elements_map_, var, index);
    }
  }
 
  std::vector<E> elements_;
  absl::flat_hash_map<const V*, int> elements_map_;
};
 
class Assignment : public PropagationBaseObject {
 public:
  typedef AssignmentContainer<IntVar, IntVarElement> IntContainer;
  typedef AssignmentContainer<IntervalVar, IntervalVarElement>
      IntervalContainer;
  typedef AssignmentContainer<SequenceVar, SequenceVarElement>
      SequenceContainer;
 
  explicit Assignment(Solver* const s);
  explicit Assignment(const Assignment* const copy);
  ~Assignment() override;
 
  void Clear();
  bool Empty() const {
    return int_var_container_.Empty() && interval_var_container_.Empty() &&
           sequence_var_container_.Empty();
  }
  int Size() const {
    return NumIntVars() + NumIntervalVars() + NumSequenceVars();
  }
  int NumIntVars() const { return int_var_container_.Size(); }
  int NumIntervalVars() const { return interval_var_container_.Size(); }
  int NumSequenceVars() const { return sequence_var_container_.Size(); }
  void Store();
  void Restore();
 
  bool Load(const std::string& filename);
#if !defined(SWIG)
  bool Load(File* file);
#endif  
  void Load(const AssignmentProto& assignment_proto);
  bool Save(const std::string& filename) const;
#if !defined(SWIG)
  bool Save(File* file) const;
#endif  // #if !defined(SWIG)
  void Save(AssignmentProto* const assignment_proto) const;
 
  void AddObjective(IntVar* const v);
  void ClearObjective() { objective_element_.Reset(nullptr); }
  IntVar* Objective() const;
  bool HasObjective() const { return (objective_element_.Var() != nullptr); }
  int64 ObjectiveMin() const;
  int64 ObjectiveMax() const;
  int64 ObjectiveValue() const;
  bool ObjectiveBound() const;
  void SetObjectiveMin(int64 m);
  void SetObjectiveMax(int64 m);
  void SetObjectiveValue(int64 value);
  void SetObjectiveRange(int64 l, int64 u);
 
  IntVarElement* Add(IntVar* const var);
  void Add(const std::vector<IntVar*>& vars);
  IntVarElement* FastAdd(IntVar* const var);
  int64 Min(const IntVar* const var) const;
  int64 Max(const IntVar* const var) const;
  int64 Value(const IntVar* const var) const;
  bool Bound(const IntVar* const var) const;
  void SetMin(const IntVar* const var, int64 m);
  void SetMax(const IntVar* const var, int64 m);
  void SetRange(const IntVar* const var, int64 l, int64 u);
  void SetValue(const IntVar* const var, int64 value);
 
  IntervalVarElement* Add(IntervalVar* const var);
  void Add(const std::vector<IntervalVar*>& vars);
  IntervalVarElement* FastAdd(IntervalVar* const var);
  int64 StartMin(const IntervalVar* const var) const;
  int64 StartMax(const IntervalVar* const var) const;
  int64 StartValue(const IntervalVar* const var) const;
  int64 DurationMin(const IntervalVar* const var) const;
  int64 DurationMax(const IntervalVar* const var) const;
  int64 DurationValue(const IntervalVar* const var) const;
  int64 EndMin(const IntervalVar* const var) const;
  int64 EndMax(const IntervalVar* const var) const;
  int64 EndValue(const IntervalVar* const var) const;
  int64 PerformedMin(const IntervalVar* const var) const;
  int64 PerformedMax(const IntervalVar* const var) const;
  int64 PerformedValue(const IntervalVar* const var) const;
  void SetStartMin(const IntervalVar* const var, int64 m);
  void SetStartMax(const IntervalVar* const var, int64 m);
  void SetStartRange(const IntervalVar* const var, int64 mi, int64 ma);
  void SetStartValue(const IntervalVar* const var, int64 value);
  void SetDurationMin(const IntervalVar* const var, int64 m);
  void SetDurationMax(const IntervalVar* const var, int64 m);
  void SetDurationRange(const IntervalVar* const var, int64 mi, int64 ma);
  void SetDurationValue(const IntervalVar* const var, int64 value);
  void SetEndMin(const IntervalVar* const var, int64 m);
  void SetEndMax(const IntervalVar* const var, int64 m);
  void SetEndRange(const IntervalVar* const var, int64 mi, int64 ma);
  void SetEndValue(const IntervalVar* const var, int64 value);
  void SetPerformedMin(const IntervalVar* const var, int64 m);
  void SetPerformedMax(const IntervalVar* const var, int64 m);
  void SetPerformedRange(const IntervalVar* const var, int64 mi, int64 ma);
  void SetPerformedValue(const IntervalVar* const var, int64 value);
 
  SequenceVarElement* Add(SequenceVar* const var);
  void Add(const std::vector<SequenceVar*>& vars);
  SequenceVarElement* FastAdd(SequenceVar* const var);
  const std::vector<int>& ForwardSequence(const SequenceVar* const var) const;
  const std::vector<int>& BackwardSequence(const SequenceVar* const var) const;
  const std::vector<int>& Unperformed(const SequenceVar* const var) const;
  void SetSequence(const SequenceVar* const var,
                   const std::vector<int>& forward_sequence,
                   const std::vector<int>& backward_sequence,
                   const std::vector<int>& unperformed);
  void SetForwardSequence(const SequenceVar* const var,
                          const std::vector<int>& forward_sequence);
  void SetBackwardSequence(const SequenceVar* const var,
                           const std::vector<int>& backward_sequence);
  void SetUnperformed(const SequenceVar* const var,
                      const std::vector<int>& unperformed);
 
  void Activate(const IntVar* const var);
  void Deactivate(const IntVar* const var);
  bool Activated(const IntVar* const var) const;
 
  void Activate(const IntervalVar* const var);
  void Deactivate(const IntervalVar* const var);
  bool Activated(const IntervalVar* const var) const;
 
  void Activate(const SequenceVar* const var);
  void Deactivate(const SequenceVar* const var);
  bool Activated(const SequenceVar* const var) const;
 
  void ActivateObjective();
  void DeactivateObjective();
  bool ActivatedObjective() const;
 
  std::string DebugString() const override;
 
  bool AreAllElementsBound() const {
    return int_var_container_.AreAllElementsBound() &&
           interval_var_container_.AreAllElementsBound() &&
           sequence_var_container_.AreAllElementsBound();
  }
 
  bool Contains(const IntVar* const var) const;
  bool Contains(const IntervalVar* const var) const;
  bool Contains(const SequenceVar* const var) const;
  void CopyIntersection(const Assignment* assignment);
  void Copy(const Assignment* assignment);
 
  // TODO(user): Add element iterators to avoid exposing container class.
  const IntContainer& IntVarContainer() const { return int_var_container_; }
  IntContainer* MutableIntVarContainer() { return &int_var_container_; }
  const IntervalContainer& IntervalVarContainer() const {
    return interval_var_container_;
  }
  IntervalContainer* MutableIntervalVarContainer() {
    return &interval_var_container_;
  }
  const SequenceContainer& SequenceVarContainer() const {
    return sequence_var_container_;
  }
  SequenceContainer* MutableSequenceVarContainer() {
    return &sequence_var_container_;
  }
  bool operator==(const Assignment& assignment) const {
    return int_var_container_ == assignment.int_var_container_ &&
           interval_var_container_ == assignment.interval_var_container_ &&
           sequence_var_container_ == assignment.sequence_var_container_ &&
           objective_element_ == assignment.objective_element_;
  }
  bool operator!=(const Assignment& assignment) const {
    return !(*this == assignment);
  }
 
 private:
  IntContainer int_var_container_;
  IntervalContainer interval_var_container_;
  SequenceContainer sequence_var_container_;
  IntVarElement objective_element_;
  DISALLOW_COPY_AND_ASSIGN(Assignment);
};
 
std::ostream& operator<<(std::ostream& out,
                         const Assignment& assignment);  
 
void SetAssignmentFromAssignment(Assignment* target_assignment,
                                 const std::vector<IntVar*>& target_vars,
                                 const Assignment* source_assignment,
                                 const std::vector<IntVar*>& source_vars);
 
class Pack : public Constraint {
 public:
  Pack(Solver* const s, const std::vector<IntVar*>& vars, int number_of_bins);
 
  ~Pack() override;
 
 
  void AddWeightedSumLessOrEqualConstantDimension(
      const std::vector<int64>& weights, const std::vector<int64>& bounds);
 
  void AddWeightedSumLessOrEqualConstantDimension(
      Solver::IndexEvaluator1 weights, const std::vector<int64>& bounds);
 
  void AddWeightedSumLessOrEqualConstantDimension(
      Solver::IndexEvaluator2 weights, const std::vector<int64>& bounds);
 
  void AddWeightedSumEqualVarDimension(const std::vector<int64>& weights,
                                       const std::vector<IntVar*>& loads);
 
  void AddWeightedSumEqualVarDimension(Solver::IndexEvaluator2 weights,
                                       const std::vector<IntVar*>& loads);
 
  void AddSumVariableWeightsLessOrEqualConstantDimension(
      const std::vector<IntVar*>& usage, const std::vector<int64>& capacity);
 
  void AddWeightedSumOfAssignedDimension(const std::vector<int64>& weights,
                                         IntVar* const cost_var);
 
  void AddCountUsedBinDimension(IntVar* const count_var);
 
  void AddCountAssignedItemsDimension(IntVar* const count_var);
 
  void Post() override;
  void ClearAll();
  void PropagateDelayed();
  void InitialPropagate() override;
  void Propagate();
  void OneDomain(int var_index);
  std::string DebugString() const override;
  bool IsUndecided(int var_index, int bin_index) const;
  void SetImpossible(int var_index, int bin_index);
  void Assign(int var_index, int bin_index);
  bool IsAssignedStatusKnown(int var_index) const;
  bool IsPossible(int var_index, int bin_index) const;
  IntVar* AssignVar(int var_index, int bin_index) const;
  void SetAssigned(int var_index);
  void SetUnassigned(int var_index);
  void RemoveAllPossibleFromBin(int bin_index);
  void AssignAllPossibleToBin(int bin_index);
  void AssignFirstPossibleToBin(int bin_index);
  void AssignAllRemainingItems();
  void UnassignAllRemainingItems();
  void Accept(ModelVisitor* const visitor) const override;
 
 private:
  bool IsInProcess() const;
  const std::vector<IntVar*> vars_;
  const int bins_;
  std::vector<Dimension*> dims_;
  std::unique_ptr<RevBitMatrix> unprocessed_;
  std::vector<std::vector<int>> forced_;
  std::vector<std::vector<int>> removed_;
  std::vector<IntVarIterator*> holes_;
  uint64 stamp_;
  Demon* demon_;
  std::vector<std::pair<int, int>> to_set_;
  std::vector<std::pair<int, int>> to_unset_;
  bool in_process_;
};
 
class DisjunctiveConstraint : public Constraint {
 public:
  DisjunctiveConstraint(Solver* const s,
                        const std::vector<IntervalVar*>& intervals,
                        const std::string& name);
  ~DisjunctiveConstraint() override;
 
  virtual SequenceVar* MakeSequenceVar() = 0;
 
  void SetTransitionTime(Solver::IndexEvaluator2 transition_time);
 
  int64 TransitionTime(int before_index, int after_index) {
    DCHECK(transition_time_);
    return transition_time_(before_index, after_index);
  }
 
#if !defined(SWIG)
  virtual const std::vector<IntVar*>& nexts() const = 0;
  virtual const std::vector<IntVar*>& actives() const = 0;
  virtual const std::vector<IntVar*>& time_cumuls() const = 0;
  virtual const std::vector<IntVar*>& time_slacks() const = 0;
#endif  // !defined(SWIG)
 
 protected:
  const std::vector<IntervalVar*> intervals_;
  Solver::IndexEvaluator2 transition_time_;
 
 private:
  DISALLOW_COPY_AND_ASSIGN(DisjunctiveConstraint);
};
 
class SolutionPool : public BaseObject {
 public:
  SolutionPool() {}
  ~SolutionPool() override {}
 
  virtual void Initialize(Assignment* const assignment) = 0;
 
  virtual void RegisterNewSolution(Assignment* const assignment) = 0;
 
  virtual void GetNextSolution(Assignment* const assignment) = 0;
 
  virtual bool SyncNeeded(Assignment* const local_assignment) = 0;
};
}  // namespace operations_research
 
#endif  // OR_TOOLS_CONSTRAINT_SOLVER_CONSTRAINT_SOLVER_H_