Solver.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (https://www.swig.org).
// Version 4.4.0
//
// Do not make changes to this file unless you know what you are doing - modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Google.OrTools.ConstraintSolver {
 
using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
 
public partial class Solver : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;
 
  internal Solver(global::System.IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Solver obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Solver obj) {
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.Dispose();
      return ptr;
    } else {
      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
    }
  }
 
  ~Solver() {
    Dispose(false);
  }
 
  public void Dispose() {
    Dispose(true);
    global::System.GC.SuppressFinalize(this);
  }
 
  protected virtual void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          operations_research_constraint_solverPINVOKE.delete_Solver(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  // Store list of delegates to avoid the GC to reclaim them.
  // This avoid the GC to collect any callback (i.e. delegate) set from C#.
  // The underlying C++ class will only store a pointer to it (i.e. no ownership).
  private List<VoidToString> displayCallbacks;
  private VoidToString StoreVoidToString(VoidToString c) {
    if (displayCallbacks == null)
      displayCallbacks = new List<VoidToString>();
    displayCallbacks.Add(c);
    return c;
  }
 
  private List<LongToLong> LongToLongCallbacks;
  private LongToLong StoreLongToLong(LongToLong c) {
    if (LongToLongCallbacks == null)
      LongToLongCallbacks = new List<LongToLong>();
    LongToLongCallbacks.Add(c);
    return c;
  }
  private List<LongLongToLong> LongLongToLongCallbacks;
  private LongLongToLong StoreLongLongToLong(LongLongToLong c) {
    if (LongLongToLongCallbacks == null)
      LongLongToLongCallbacks = new List<LongLongToLong>();
    LongLongToLongCallbacks.Add(c);
    return c;
  }
  private List<LongLongLongToLong> LongLongLongToLongCallbacks;
  private LongLongLongToLong StoreLongLongLongToLong(LongLongLongToLong c) {
    if (LongLongLongToLongCallbacks == null)
      LongLongLongToLongCallbacks = new List<LongLongLongToLong>();
    LongLongLongToLongCallbacks.Add(c);
    return c;
  }
 
  private List<VoidToBoolean> limiterCallbacks;
  private VoidToBoolean StoreVoidToBoolean(VoidToBoolean limiter) {
    if (limiterCallbacks == null)
      limiterCallbacks = new List<VoidToBoolean>();
    limiterCallbacks.Add(limiter);
    return limiter;
  }
 
  private List<LongLongLongToBoolean> variableValueComparatorCallbacks;
  private LongLongLongToBoolean StoreLongLongLongToBoolean(
    LongLongLongToBoolean c) {
    if (variableValueComparatorCallbacks == null)
      variableValueComparatorCallbacks = new List<LongLongLongToBoolean>();
    variableValueComparatorCallbacks.Add(c);
    return c;
  }
 
  private List<LongToBoolean> indexFilter1Callbacks;
  private LongToBoolean StoreLongToBoolean(LongToBoolean c) {
    if (indexFilter1Callbacks == null)
      indexFilter1Callbacks = new List<LongToBoolean>();
    indexFilter1Callbacks.Add(c);
    return c;
  }
 
  private List<LongToVoid> objectiveWatcherCallbacks;
  private LongToVoid StoreLongToVoid(LongToVoid c) {
    if (objectiveWatcherCallbacks == null)
      objectiveWatcherCallbacks = new List<LongToVoid>();
    objectiveWatcherCallbacks.Add(c);
    return c;
  }
 
  private List<SolverToVoid> actionCallbacks;
  private SolverToVoid StoreSolverToVoid(SolverToVoid action) {
    if (actionCallbacks == null)
      actionCallbacks = new List<SolverToVoid>();
    actionCallbacks.Add(action);
    return action;
  }
 
  private List<VoidToVoid> closureCallbacks;
  private VoidToVoid StoreVoidToVoid(VoidToVoid closure) {
    if (closureCallbacks == null)
      closureCallbacks = new List<VoidToVoid>();
    closureCallbacks.Add(closure);
    return closure;
  }
 
  // note: Should be store in LocalSearchOperator
  private List<IntIntToLong> evaluatorCallbacks;
  private IntIntToLong StoreIntIntToLong(IntIntToLong evaluator) {
    if (evaluatorCallbacks == null)
      evaluatorCallbacks = new List<IntIntToLong>();
    evaluatorCallbacks.Add(evaluator);
    return evaluator;
  }
 
  public partial class IntegerCastInfo : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal IntegerCastInfo(global::System.IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef getCPtr(IntegerCastInfo obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(IntegerCastInfo obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~IntegerCastInfo() {
      Dispose(false);
    }
  
    public void Dispose() {
      Dispose(true);
      global::System.GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing) {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            operations_research_constraint_solverPINVOKE.delete_Solver_IntegerCastInfo(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public IntegerCastInfo() : this(operations_research_constraint_solverPINVOKE.new_Solver_IntegerCastInfo__SWIG_0(), true) {
    }
  
    public IntegerCastInfo(IntVar v, IntExpr e, Constraint c) : this(operations_research_constraint_solverPINVOKE.new_Solver_IntegerCastInfo__SWIG_1(IntVar.getCPtr(v), IntExpr.getCPtr(e), Constraint.getCPtr(c)), true) {
    }
  
    public IntVar variable {
      set {
        operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_variable_set(swigCPtr, IntVar.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_variable_get(swigCPtr);
        IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
        return ret;
      } 
    }
  
    public IntExpr expression {
      set {
        operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_expression_set(swigCPtr, IntExpr.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_expression_get(swigCPtr);
        IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
        return ret;
      } 
    }
  
    public Constraint maintainer {
      set {
        operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_maintainer_set(swigCPtr, Constraint.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_IntegerCastInfo_maintainer_get(swigCPtr);
        Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
        return ret;
      } 
    }
  
  }
 
  public Solver(string name) : this(operations_research_constraint_solverPINVOKE.new_Solver__SWIG_0(name), true) {
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Solver(string name, Google.OrTools.ConstraintSolver.ConstraintSolverParameters parameters) : this(operations_research_constraint_solverPINVOKE.new_Solver__SWIG_1(name, ProtoHelper.ProtoToByteArray(parameters, out var buffer), buffer), true) {
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Google.OrTools.ConstraintSolver.ConstraintSolverParameters Parameters() {
  System.IntPtr dataPointer = operations_research_constraint_solverPINVOKE.Solver_Parameters(swigCPtr);
  try
  {
    int size = System.Runtime.InteropServices.Marshal.ReadInt32(dataPointer);
    unsafe
    {
      var data = new System.ReadOnlySpan<byte>((dataPointer + sizeof(int)).ToPointer(), size);
      return Google.OrTools.ConstraintSolver.ConstraintSolverParameters.Parser.ParseFrom(data);
    }
  } catch (Google.Protobuf.InvalidProtocolBufferException /*e*/)
  {
    throw new System.Exception("Unable to parse Google.OrTools.ConstraintSolver.ConstraintSolverParameters protocol message.");
  }
  finally
  {
    Google.OrTools.Init.CppBridge.DeleteByteArray(dataPointer);
  }
}
 
  public SWIGTYPE_p_operations_research__ConstraintSolverParameters ConstParameters() {
    SWIGTYPE_p_operations_research__ConstraintSolverParameters ret = new SWIGTYPE_p_operations_research__ConstraintSolverParameters(operations_research_constraint_solverPINVOKE.Solver_ConstParameters(swigCPtr), false);
    return ret;
  }
 
  public static Google.OrTools.ConstraintSolver.ConstraintSolverParameters DefaultSolverParameters() {
  System.IntPtr dataPointer = operations_research_constraint_solverPINVOKE.Solver_DefaultSolverParameters();
  try
  {
    int size = System.Runtime.InteropServices.Marshal.ReadInt32(dataPointer);
    unsafe
    {
      var data = new System.ReadOnlySpan<byte>((dataPointer + sizeof(int)).ToPointer(), size);
      return Google.OrTools.ConstraintSolver.ConstraintSolverParameters.Parser.ParseFrom(data);
    }
  } catch (Google.Protobuf.InvalidProtocolBufferException /*e*/)
  {
    throw new System.Exception("Unable to parse Google.OrTools.ConstraintSolver.ConstraintSolverParameters protocol message.");
  }
  finally
  {
    Google.OrTools.Init.CppBridge.DeleteByteArray(dataPointer);
  }
}
 
  public void Add(Constraint c) {
    operations_research_constraint_solverPINVOKE.Solver_Add(swigCPtr, Constraint.getCPtr(c));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void AddCastConstraint(CastConstraint constraint, IntVar target_var, IntExpr expr) {
    operations_research_constraint_solverPINVOKE.Solver_AddCastConstraint(swigCPtr, CastConstraint.getCPtr(constraint), IntVar.getCPtr(target_var), IntExpr.getCPtr(expr));
  }
 
  public bool Solve(DecisionBuilder db, SearchMonitorVector monitors) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitorVector.getCPtr(monitors));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool Solve(DecisionBuilder db) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db));
    return ret;
  }
 
  public bool Solve(DecisionBuilder db, SearchMonitor m1) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1));
    return ret;
  }
 
  public bool Solve(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_3(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2));
    return ret;
  }
 
  public bool Solve(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_4(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2), SearchMonitor.getCPtr(m3));
    return ret;
  }
 
  public bool Solve(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3, SearchMonitor m4) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_Solve__SWIG_5(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2), SearchMonitor.getCPtr(m3), SearchMonitor.getCPtr(m4));
    return ret;
  }
 
  public void NewSearchAux(DecisionBuilder db, SearchMonitorVector monitors) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitorVector.getCPtr(monitors));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void NewSearchAux(DecisionBuilder db) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db));
  }
 
  public void NewSearchAux(DecisionBuilder db, SearchMonitor m1) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1));
  }
 
  public void NewSearchAux(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_3(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2));
  }
 
  public void NewSearchAux(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_4(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2), SearchMonitor.getCPtr(m3));
  }
 
  public void NewSearchAux(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3, SearchMonitor m4) {
    operations_research_constraint_solverPINVOKE.Solver_NewSearchAux__SWIG_5(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2), SearchMonitor.getCPtr(m3), SearchMonitor.getCPtr(m4));
  }
 
  public bool NextSolution() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_NextSolution(swigCPtr);
    return ret;
  }
 
  public void RestartSearch() {
    operations_research_constraint_solverPINVOKE.Solver_RestartSearch(swigCPtr);
  }
 
  public void EndSearchAux() {
    operations_research_constraint_solverPINVOKE.Solver_EndSearchAux(swigCPtr);
  }
 
  public bool SolveAndCommit(DecisionBuilder db, SearchMonitorVector monitors) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_SolveAndCommit__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitorVector.getCPtr(monitors));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool SolveAndCommit(DecisionBuilder db) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_SolveAndCommit__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db));
    return ret;
  }
 
  public bool SolveAndCommit(DecisionBuilder db, SearchMonitor m1) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_SolveAndCommit__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1));
    return ret;
  }
 
  public bool SolveAndCommit(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_SolveAndCommit__SWIG_3(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2));
    return ret;
  }
 
  public bool SolveAndCommit(DecisionBuilder db, SearchMonitor m1, SearchMonitor m2, SearchMonitor m3) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_SolveAndCommit__SWIG_4(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(m1), SearchMonitor.getCPtr(m2), SearchMonitor.getCPtr(m3));
    return ret;
  }
 
  public bool CheckAssignment(Assignment solution) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_CheckAssignment(swigCPtr, Assignment.getCPtr(solution));
    return ret;
  }
 
  public bool CheckConstraint(Constraint ct) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_CheckConstraint(swigCPtr, Constraint.getCPtr(ct));
    return ret;
  }
 
  public int State() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_State(swigCPtr);
    return ret;
  }
 
  public void Fail() {
    operations_research_constraint_solverPINVOKE.Solver_Fail(swigCPtr);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public string ToString() {
    string ret = operations_research_constraint_solverPINVOKE.Solver_ToString(swigCPtr);
    return ret;
  }
 
  public static long MemoryUsage() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_MemoryUsage();
    return ret;
  }
 
  public long WallTime() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_WallTime(swigCPtr);
    return ret;
  }
 
  public long Branches() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_Branches(swigCPtr);
    return ret;
  }
 
  public long Solutions() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_Solutions(swigCPtr);
    return ret;
  }
 
  public long UncheckedSolutions() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_UncheckedSolutions(swigCPtr);
    return ret;
  }
 
  public long DemonRuns(int p) {
    long ret = operations_research_constraint_solverPINVOKE.Solver_DemonRuns(swigCPtr, p);
    return ret;
  }
 
  public long Failures() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_Failures(swigCPtr);
    return ret;
  }
 
  public long Neighbors() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_Neighbors(swigCPtr);
    return ret;
  }
 
  public void ClearNeighbors() {
    operations_research_constraint_solverPINVOKE.Solver_ClearNeighbors(swigCPtr);
  }
 
  public void IncrementNeighbors() {
    operations_research_constraint_solverPINVOKE.Solver_IncrementNeighbors(swigCPtr);
  }
 
  public long FilteredNeighbors() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_FilteredNeighbors(swigCPtr);
    return ret;
  }
 
  public long AcceptedNeighbors() {
    long ret = operations_research_constraint_solverPINVOKE.Solver_AcceptedNeighbors(swigCPtr);
    return ret;
  }
 
  public ulong Stamp() {
    ulong ret = operations_research_constraint_solverPINVOKE.Solver_Stamp(swigCPtr);
    return ret;
  }
 
  public ulong FailStamp() {
    ulong ret = operations_research_constraint_solverPINVOKE.Solver_FailStamp(swigCPtr);
    return ret;
  }
 
  public void SetContext(string context) {
    operations_research_constraint_solverPINVOKE.Solver_SetContext(swigCPtr, context);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public string Context() {
    string ret = operations_research_constraint_solverPINVOKE.Solver_Context(swigCPtr);
    return ret;
  }
 
  public void SetOptimizationDirection(int direction) {
    operations_research_constraint_solverPINVOKE.Solver_SetOptimizationDirection(swigCPtr, direction);
  }
 
  public void SetGuidedLocalSearchPenaltyCallback( LongLongLongToLong  penalty_callback) {
    operations_research_constraint_solverPINVOKE.Solver_SetGuidedLocalSearchPenaltyCallback(swigCPtr,  StoreLongLongLongToLong(penalty_callback) );
  }
 
  public long GetGuidedLocalSearchPenalty(long i, long j, long k) {
    long ret = operations_research_constraint_solverPINVOKE.Solver_GetGuidedLocalSearchPenalty(swigCPtr, i, j, k);
    return ret;
  }
 
  public IntVar MakeIntVar(long min, long max, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_0(swigCPtr, min, max, name);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVar MakeIntVar( long[]  values, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_1(swigCPtr,  values.Length, values , name);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVar MakeIntVar( int[]  values, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_2(swigCPtr,  values.Length, values , name);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVar MakeIntVar(long min, long max) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_3(swigCPtr, min, max);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIntVar( long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_4(swigCPtr,  values.Length, values );
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIntVar( int[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntVar__SWIG_5(swigCPtr,  values.Length, values );
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeBoolVar(string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBoolVar__SWIG_0(swigCPtr, name);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVar MakeBoolVar() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBoolVar__SWIG_1(swigCPtr);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIntConst(long val, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntConst__SWIG_0(swigCPtr, val, name);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVar MakeIntConst(long val) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntConst__SWIG_1(swigCPtr, val);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeSum(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSum__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeSum(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSum__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeSum(IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSum__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeScalProd(IntVarVector vars,  long[]  coefs) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProd__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  coefs.Length, coefs );
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeScalProd(IntVarVector vars,  int[]  coefs) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProd__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  coefs.Length, coefs );
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeDifference(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDifference__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeDifference(long value, IntExpr expr) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDifference__SWIG_1(swigCPtr, value, IntExpr.getCPtr(expr));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeOpposite(IntExpr expr) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOpposite(swigCPtr, IntExpr.getCPtr(expr));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeProd(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeProd__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeProd(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeProd__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeDiv(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDiv__SWIG_0(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeDiv(IntExpr numerator, IntExpr denominator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDiv__SWIG_1(swigCPtr, IntExpr.getCPtr(numerator), IntExpr.getCPtr(denominator));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeAbs(IntExpr expr) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAbs(swigCPtr, IntExpr.getCPtr(expr));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeSquare(IntExpr expr) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSquare(swigCPtr, IntExpr.getCPtr(expr));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakePower(IntExpr expr, long n) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePower(swigCPtr, IntExpr.getCPtr(expr), n);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeElement( long[]  values, IntVar index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElement__SWIG_0(swigCPtr,  values.Length, values , IntVar.getCPtr(index));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeElement( int[]  values, IntVar index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElement__SWIG_1(swigCPtr,  values.Length, values , IntVar.getCPtr(index));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeElement( LongToLong  values, IntVar index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElement__SWIG_2(swigCPtr,  StoreLongToLong(values) , IntVar.getCPtr(index));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMonotonicElement( LongToLong  values, bool increasing, IntVar index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMonotonicElement(swigCPtr,  StoreLongToLong(values) , increasing, IntVar.getCPtr(index));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeElement( LongLongToLong  values, IntVar index1, IntVar index2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElement__SWIG_3(swigCPtr,  StoreLongLongToLong(values) , IntVar.getCPtr(index1), IntVar.getCPtr(index2));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeElement(IntVarVector vars, IntVar index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElement__SWIG_4(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(index));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeIndexExpression(IntVarVector vars, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIndexExpression(swigCPtr, IntVarVector.getCPtr(vars), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeIfThenElseCt(IntVar condition, IntExpr then_expr, IntExpr else_expr, IntVar target_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIfThenElseCt(swigCPtr, IntVar.getCPtr(condition), IntExpr.getCPtr(then_expr), IntExpr.getCPtr(else_expr), IntVar.getCPtr(target_var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMin(IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMin__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeMin(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMin__SWIG_1(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMin(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMin__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMin(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMin__SWIG_3(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMax(IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMax__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntExpr MakeMax(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMax__SWIG_1(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMax(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMax__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeMax(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMax__SWIG_3(swigCPtr, IntExpr.getCPtr(expr), value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeConvexPiecewiseExpr(IntExpr expr, long early_cost, long early_date, long late_date, long late_cost) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeConvexPiecewiseExpr(swigCPtr, IntExpr.getCPtr(expr), early_cost, early_date, late_date, late_cost);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeSemiContinuousExpr(IntExpr expr, long fixed_charge, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSemiContinuousExpr(swigCPtr, IntExpr.getCPtr(expr), fixed_charge, step);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeModulo(IntExpr x, long mod) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeModulo__SWIG_0(swigCPtr, IntExpr.getCPtr(x), mod);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeModulo(IntExpr x, IntExpr mod) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeModulo__SWIG_1(swigCPtr, IntExpr.getCPtr(x), IntExpr.getCPtr(mod));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntExpr MakeConditionalExpression(IntVar condition, IntExpr expr, long unperformed_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeConditionalExpression(swigCPtr, IntVar.getCPtr(condition), IntExpr.getCPtr(expr), unperformed_value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public Constraint MakeTrueConstraint() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTrueConstraint(swigCPtr);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeFalseConstraint() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFalseConstraint__SWIG_0(swigCPtr);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeFalseConstraint(string explanation) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFalseConstraint__SWIG_1(swigCPtr, explanation);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeIsEqualCstCt(IntExpr var, long value, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsEqualCstCt(swigCPtr, IntExpr.getCPtr(var), value, IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsEqualCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsEqualCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsEqualCt(IntExpr v1, IntExpr v2, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsEqualCt(swigCPtr, IntExpr.getCPtr(v1), IntExpr.getCPtr(v2), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsEqualVar(IntExpr v1, IntExpr v2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsEqualVar(swigCPtr, IntExpr.getCPtr(v1), IntExpr.getCPtr(v2));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeEquality(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeEquality__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeEquality(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeEquality__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeEquality(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeEquality__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsDifferentCstCt(IntExpr var, long value, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsDifferentCstCt(swigCPtr, IntExpr.getCPtr(var), value, IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsDifferentCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsDifferentCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsDifferentVar(IntExpr v1, IntExpr v2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsDifferentVar(swigCPtr, IntExpr.getCPtr(v1), IntExpr.getCPtr(v2));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsDifferentCt(IntExpr v1, IntExpr v2, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsDifferentCt(swigCPtr, IntExpr.getCPtr(v1), IntExpr.getCPtr(v2), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNonEquality(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonEquality__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNonEquality(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonEquality__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNonEquality(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonEquality__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsLessOrEqualCstCt(IntExpr var, long value, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessOrEqualCstCt(swigCPtr, IntExpr.getCPtr(var), value, IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsLessOrEqualCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessOrEqualCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsLessOrEqualVar(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessOrEqualVar(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsLessOrEqualCt(IntExpr left, IntExpr right, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessOrEqualCt(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLessOrEqual(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLessOrEqual__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLessOrEqual(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLessOrEqual__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLessOrEqual(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLessOrEqual__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsGreaterOrEqualCstCt(IntExpr var, long value, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterOrEqualCstCt(swigCPtr, IntExpr.getCPtr(var), value, IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsGreaterOrEqualCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterOrEqualCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsGreaterOrEqualVar(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterOrEqualVar(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsGreaterOrEqualCt(IntExpr left, IntExpr right, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterOrEqualCt(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreaterOrEqual(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreaterOrEqual__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreaterOrEqual(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreaterOrEqual__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreaterOrEqual(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreaterOrEqual__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsGreaterCstCt(IntExpr v, long c, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterCstCt(swigCPtr, IntExpr.getCPtr(v), c, IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsGreaterCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsGreaterVar(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterVar(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsGreaterCt(IntExpr left, IntExpr right, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsGreaterCt(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreater(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreater__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreater(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreater__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeGreater(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGreater__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsLessCstCt(IntExpr v, long c, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessCstCt(swigCPtr, IntExpr.getCPtr(v), c, IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsLessCstVar(IntExpr var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessCstVar(swigCPtr, IntExpr.getCPtr(var), value);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsLessVar(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessVar(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsLessCt(IntExpr left, IntExpr right, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLessCt(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right), IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLess(IntExpr left, IntExpr right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLess__SWIG_0(swigCPtr, IntExpr.getCPtr(left), IntExpr.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLess(IntExpr expr, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLess__SWIG_1(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeLess(IntExpr expr, int value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLess__SWIG_2(swigCPtr, IntExpr.getCPtr(expr), value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeSumLessOrEqual(IntVarVector vars, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumLessOrEqual(swigCPtr, IntVarVector.getCPtr(vars), cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeSumGreaterOrEqual(IntVarVector vars, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumGreaterOrEqual(swigCPtr, IntVarVector.getCPtr(vars), cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeSumEquality(IntVarVector vars, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumEquality__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeSumEquality(IntVarVector vars, IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumEquality__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdEquality(IntVarVector vars,  long[]  coefficients, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdEquality__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdEquality(IntVarVector vars,  int[]  coefficients, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdEquality__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdEquality(IntVarVector vars,  long[]  coefficients, IntVar target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdEquality__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , IntVar.getCPtr(target));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdEquality(IntVarVector vars,  int[]  coefficients, IntVar target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdEquality__SWIG_3(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , IntVar.getCPtr(target));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdGreaterOrEqual(IntVarVector vars,  long[]  coeffs, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdGreaterOrEqual__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  coeffs.Length, coeffs , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdGreaterOrEqual(IntVarVector vars,  int[]  coeffs, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdGreaterOrEqual__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  coeffs.Length, coeffs , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdLessOrEqual(IntVarVector vars,  long[]  coefficients, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdLessOrEqual__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeScalProdLessOrEqual(IntVarVector vars,  int[]  coefficients, long cst) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScalProdLessOrEqual__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  coefficients.Length, coefficients , cst);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeMinEquality(IntVarVector vars, IntVar min_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMinEquality(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(min_var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeMaxEquality(IntVarVector vars, IntVar max_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMaxEquality(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(max_var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeElementEquality( long[]  vals, IntVar index, IntVar target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElementEquality__SWIG_0(swigCPtr,  vals.Length, vals , IntVar.getCPtr(index), IntVar.getCPtr(target));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeElementEquality( int[]  vals, IntVar index, IntVar target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElementEquality__SWIG_1(swigCPtr,  vals.Length, vals , IntVar.getCPtr(index), IntVar.getCPtr(target));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeElementEquality(IntVarVector vars, IntVar index, IntVar target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElementEquality__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(index), IntVar.getCPtr(target));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeElementEquality(IntVarVector vars, IntVar index, long target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeElementEquality__SWIG_3(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(index), target);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeAbsEquality(IntVar var, IntVar abs_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAbsEquality(swigCPtr, IntVar.getCPtr(var), IntVar.getCPtr(abs_var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIndexOfConstraint(IntVarVector vars, IntVar index, long target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIndexOfConstraint(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(index), target);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Demon MakeConstraintInitialPropagateCallback(Constraint ct) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeConstraintInitialPropagateCallback(swigCPtr, Constraint.getCPtr(ct));
    Demon ret = (cPtr == global::System.IntPtr.Zero) ? null : new Demon(cPtr, false);
    return ret;
  }
 
  public Demon MakeDelayedConstraintInitialPropagateCallback(Constraint ct) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDelayedConstraintInitialPropagateCallback(swigCPtr, Constraint.getCPtr(ct));
    Demon ret = (cPtr == global::System.IntPtr.Zero) ? null : new Demon(cPtr, false);
    return ret;
  }
 
  public Demon MakeClosureDemon( VoidToVoid  closure) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeClosureDemon(swigCPtr,  StoreVoidToVoid(closure) );
    Demon ret = (cPtr == global::System.IntPtr.Zero) ? null : new Demon(cPtr, false);
    return ret;
  }
 
  public Constraint MakeBetweenCt(IntExpr expr, long l, long u) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBetweenCt(swigCPtr, IntExpr.getCPtr(expr), l, u);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNotBetweenCt(IntExpr expr, long l, long u) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNotBetweenCt(swigCPtr, IntExpr.getCPtr(expr), l, u);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsBetweenCt(IntExpr expr, long l, long u, IntVar b) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsBetweenCt(swigCPtr, IntExpr.getCPtr(expr), l, u, IntVar.getCPtr(b));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsBetweenVar(IntExpr v, long l, long u) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsBetweenVar(swigCPtr, IntExpr.getCPtr(v), l, u);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeMemberCt(IntExpr expr,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMemberCt__SWIG_0(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeMemberCt(IntExpr expr,  int[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMemberCt__SWIG_1(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNotMemberCt(IntExpr expr,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNotMemberCt__SWIG_0(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNotMemberCt(IntExpr expr,  int[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNotMemberCt__SWIG_1(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNotMemberCt(IntExpr expr,  long[]  starts,  long[]  ends) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNotMemberCt__SWIG_2(swigCPtr, IntExpr.getCPtr(expr),  starts.Length, starts ,  ends.Length, ends );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeNotMemberCt(IntExpr expr,  int[]  starts,  int[]  ends) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNotMemberCt__SWIG_3(swigCPtr, IntExpr.getCPtr(expr),  starts.Length, starts ,  ends.Length, ends );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsMemberCt(IntExpr expr,  long[]  values, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsMemberCt__SWIG_0(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values , IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIsMemberCt(IntExpr expr,  int[]  values, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsMemberCt__SWIG_1(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values , IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsMemberVar(IntExpr expr,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsMemberVar__SWIG_0(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntVar MakeIsMemberVar(IntExpr expr,  int[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsMemberVar__SWIG_1(swigCPtr, IntExpr.getCPtr(expr),  values.Length, values );
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeCount(IntVarVector vars, long value, long max_count) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCount__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), value, max_count);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCount(IntVarVector vars, long value, IntVar max_count) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCount__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), value, IntVar.getCPtr(max_count));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  long[]  values, IntVarVector cards) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values , IntVarVector.getCPtr(cards));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  int[]  values, IntVarVector cards) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values , IntVarVector.getCPtr(cards));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars, IntVarVector cards) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(cards));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars, long card_min, long card_max, long card_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_3(swigCPtr, IntVarVector.getCPtr(vars), card_min, card_max, card_size);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  long[]  card_min,  long[]  card_max) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_4(swigCPtr, IntVarVector.getCPtr(vars),  card_min.Length, card_min ,  card_max.Length, card_max );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  int[]  card_min,  int[]  card_max) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_5(swigCPtr, IntVarVector.getCPtr(vars),  card_min.Length, card_min ,  card_max.Length, card_max );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  long[]  values,  long[]  card_min,  long[]  card_max) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_6(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values ,  card_min.Length, card_min ,  card_max.Length, card_max );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDistribute(IntVarVector vars,  int[]  values,  int[]  card_min,  int[]  card_max) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDistribute__SWIG_7(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values ,  card_min.Length, card_min ,  card_max.Length, card_max );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDeviation(IntVarVector vars, IntVar deviation_var, long total_sum) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDeviation(swigCPtr, IntVarVector.getCPtr(vars), IntVar.getCPtr(deviation_var), total_sum);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeAllDifferent(IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllDifferent__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeAllDifferent(IntVarVector vars, bool stronger_propagation) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllDifferent__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), stronger_propagation);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeAllDifferentExcept(IntVarVector vars, long escape_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllDifferentExcept(swigCPtr, IntVarVector.getCPtr(vars), escape_value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeSortingConstraint(IntVarVector vars, IntVarVector sorted) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSortingConstraint(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(sorted));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeLexicalLess(IntVarVector left, IntVarVector right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicalLess(swigCPtr, IntVarVector.getCPtr(left), IntVarVector.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeLexicalLessOrEqual(IntVarVector left, IntVarVector right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicalLessOrEqual(swigCPtr, IntVarVector.getCPtr(left), IntVarVector.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeLexicalLessOrEqualWithOffsets(IntVarVector left, IntVarVector right,  long[]  offsets) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicalLessOrEqualWithOffsets(swigCPtr, IntVarVector.getCPtr(left), IntVarVector.getCPtr(right),  offsets.Length, offsets );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeIsLexicalLessOrEqualWithOffsetsCt(IntVarVector left, IntVarVector right,  long[]  offsets, IntVar boolvar) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIsLexicalLessOrEqualWithOffsetsCt(swigCPtr, IntVarVector.getCPtr(left), IntVarVector.getCPtr(right),  offsets.Length, offsets , IntVar.getCPtr(boolvar));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeInversePermutationConstraint(IntVarVector left, IntVarVector right) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeInversePermutationConstraint(swigCPtr, IntVarVector.getCPtr(left), IntVarVector.getCPtr(right));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeIndexOfFirstMaxValueConstraint(IntVar index, IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIndexOfFirstMaxValueConstraint(swigCPtr, IntVar.getCPtr(index), IntVarVector.getCPtr(vars));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeIndexOfFirstMinValueConstraint(IntVar index, IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIndexOfFirstMinValueConstraint(swigCPtr, IntVar.getCPtr(index), IntVarVector.getCPtr(vars));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNullIntersect(IntVarVector first_vars, IntVarVector second_vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNullIntersect(swigCPtr, IntVarVector.getCPtr(first_vars), IntVarVector.getCPtr(second_vars));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNullIntersectExcept(IntVarVector first_vars, IntVarVector second_vars, long escape_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNullIntersectExcept(swigCPtr, IntVarVector.getCPtr(first_vars), IntVarVector.getCPtr(second_vars), escape_value);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNoCycle(IntVarVector nexts, IntVarVector active,  LongToBoolean  sink_handler) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNoCycle__SWIG_0(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active),  StoreLongToBoolean(sink_handler) );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNoCycle(IntVarVector nexts, IntVarVector active) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNoCycle__SWIG_1(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNoCycle(IntVarVector nexts, IntVarVector active,  LongToBoolean  sink_handler, bool assume_paths) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNoCycle__SWIG_2(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active),  StoreLongToBoolean(sink_handler) , assume_paths);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCircuit(IntVarVector nexts) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCircuit(swigCPtr, IntVarVector.getCPtr(nexts));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeSubCircuit(IntVarVector nexts) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSubCircuit(swigCPtr, IntVarVector.getCPtr(nexts));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakePathCumul(IntVarVector nexts, IntVarVector active, IntVarVector cumuls, IntVarVector transits) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePathCumul__SWIG_0(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active), IntVarVector.getCPtr(cumuls), IntVarVector.getCPtr(transits));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeDelayedPathCumul(IntVarVector nexts, IntVarVector active, IntVarVector cumuls, IntVarVector transits) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDelayedPathCumul(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active), IntVarVector.getCPtr(cumuls), IntVarVector.getCPtr(transits));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakePathCumul(IntVarVector nexts, IntVarVector active, IntVarVector cumuls,  LongLongToLong  transit_evaluator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePathCumul__SWIG_1(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active), IntVarVector.getCPtr(cumuls),  StoreLongLongToLong(transit_evaluator) );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakePathCumul(IntVarVector nexts, IntVarVector active, IntVarVector cumuls, IntVarVector slacks,  LongLongToLong  transit_evaluator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePathCumul__SWIG_2(swigCPtr, IntVarVector.getCPtr(nexts), IntVarVector.getCPtr(active), IntVarVector.getCPtr(cumuls), IntVarVector.getCPtr(slacks),  StoreLongLongToLong(transit_evaluator) );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakePathConnected(IntVarVector nexts,  long[]  sources,  long[]  sinks, IntVarVector status) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePathConnected(swigCPtr, IntVarVector.getCPtr(nexts),  sources.Length, sources ,  sinks.Length, sinks , IntVarVector.getCPtr(status));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeMapDomain(IntVar var, IntVarVector actives) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMapDomain(swigCPtr, IntVar.getCPtr(var), IntVarVector.getCPtr(actives));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeAllowedAssignments(IntVarVector vars, IntTupleSet tuples) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllowedAssignments(swigCPtr, IntVarVector.getCPtr(vars), IntTupleSet.getCPtr(tuples));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeTransitionConstraint(IntVarVector vars, IntTupleSet transition_table, long initial_state,  long[]  final_states) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTransitionConstraint__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), IntTupleSet.getCPtr(transition_table), initial_state,  final_states.Length, final_states );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeTransitionConstraint(IntVarVector vars, IntTupleSet transition_table, long initial_state,  int[]  final_states) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTransitionConstraint__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), IntTupleSet.getCPtr(transition_table), initial_state,  final_states.Length, final_states );
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, IntVarVector x_size, IntVarVector y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingBoxesConstraint__SWIG_0(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), IntVarVector.getCPtr(x_size), IntVarVector.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingBoxesConstraint__SWIG_1(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), SWIGTYPE_p_absl__SpanT_long_const_t.getCPtr(x_size), SWIGTYPE_p_absl__SpanT_long_const_t.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingBoxesConstraint__SWIG_2(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), SWIGTYPE_p_absl__SpanT_int_const_t.getCPtr(x_size), SWIGTYPE_p_absl__SpanT_int_const_t.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingNonStrictBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, IntVarVector x_size, IntVarVector y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_0(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), IntVarVector.getCPtr(x_size), IntVarVector.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingNonStrictBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_1(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), SWIGTYPE_p_absl__SpanT_long_const_t.getCPtr(x_size), SWIGTYPE_p_absl__SpanT_long_const_t.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeNonOverlappingNonStrictBoxesConstraint(IntVarVector x_vars, IntVarVector y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_2(swigCPtr, IntVarVector.getCPtr(x_vars), IntVarVector.getCPtr(y_vars), SWIGTYPE_p_absl__SpanT_int_const_t.getCPtr(x_size), SWIGTYPE_p_absl__SpanT_int_const_t.getCPtr(y_size));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Pack MakePack(IntVarVector vars, int number_of_bins) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePack(swigCPtr, IntVarVector.getCPtr(vars), number_of_bins);
    Pack ret = (cPtr == global::System.IntPtr.Zero) ? null : new Pack(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntervalVar MakeFixedDurationIntervalVar(long start_min, long start_max, long duration, bool optional, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationIntervalVar__SWIG_0(swigCPtr, start_min, start_max, duration, optional, name);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntervalVar MakeFixedDurationIntervalVar(IntVar start_variable, long duration, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationIntervalVar__SWIG_1(swigCPtr, IntVar.getCPtr(start_variable), duration, name);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntervalVar MakeFixedDurationIntervalVar(IntVar start_variable, long duration, IntVar performed_variable, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationIntervalVar__SWIG_2(swigCPtr, IntVar.getCPtr(start_variable), duration, IntVar.getCPtr(performed_variable), name);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntervalVar MakeFixedInterval(long start, long duration, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedInterval(swigCPtr, start, duration, name);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntervalVar MakeIntervalVar(long start_min, long start_max, long duration_min, long duration_max, long end_min, long end_max, bool optional, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalVar(swigCPtr, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void MakeIntervalVarArray(int count, long start_min, long start_max, long duration_min, long duration_max, long end_min, long end_max, bool optional, string name, IntervalVarVector array) {
    operations_research_constraint_solverPINVOKE.Solver_MakeIntervalVarArray(swigCPtr, count, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name, IntervalVarVector.getCPtr(array));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public IntervalVar MakeMirrorInterval(IntervalVar interval_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMirrorInterval(swigCPtr, IntervalVar.getCPtr(interval_var));
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeFixedDurationStartSyncedOnStartIntervalVar(IntervalVar interval_var, long duration, long offset) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationStartSyncedOnStartIntervalVar(swigCPtr, IntervalVar.getCPtr(interval_var), duration, offset);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeFixedDurationStartSyncedOnEndIntervalVar(IntervalVar interval_var, long duration, long offset) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationStartSyncedOnEndIntervalVar(swigCPtr, IntervalVar.getCPtr(interval_var), duration, offset);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeFixedDurationEndSyncedOnStartIntervalVar(IntervalVar interval_var, long duration, long offset) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationEndSyncedOnStartIntervalVar(swigCPtr, IntervalVar.getCPtr(interval_var), duration, offset);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeFixedDurationEndSyncedOnEndIntervalVar(IntervalVar interval_var, long duration, long offset) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFixedDurationEndSyncedOnEndIntervalVar(swigCPtr, IntervalVar.getCPtr(interval_var), duration, offset);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeIntervalRelaxedMin(IntervalVar interval_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalRelaxedMin(swigCPtr, IntervalVar.getCPtr(interval_var));
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar MakeIntervalRelaxedMax(IntervalVar interval_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalRelaxedMax(swigCPtr, IntervalVar.getCPtr(interval_var));
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIntervalVarRelation(IntervalVar t, int r, long d) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalVarRelation__SWIG_0(swigCPtr, IntervalVar.getCPtr(t), r, d);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIntervalVarRelation(IntervalVar t1, int r, IntervalVar t2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalVarRelation__SWIG_1(swigCPtr, IntervalVar.getCPtr(t1), r, IntervalVar.getCPtr(t2));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeIntervalVarRelationWithDelay(IntervalVar t1, int r, IntervalVar t2, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeIntervalVarRelationWithDelay(swigCPtr, IntervalVar.getCPtr(t1), r, IntervalVar.getCPtr(t2), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeTemporalDisjunction(IntervalVar t1, IntervalVar t2, IntVar alt) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTemporalDisjunction__SWIG_0(swigCPtr, IntervalVar.getCPtr(t1), IntervalVar.getCPtr(t2), IntVar.getCPtr(alt));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint MakeTemporalDisjunction(IntervalVar t1, IntervalVar t2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTemporalDisjunction__SWIG_1(swigCPtr, IntervalVar.getCPtr(t1), IntervalVar.getCPtr(t2));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public DisjunctiveConstraint MakeDisjunctiveConstraint(IntervalVarVector intervals, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDisjunctiveConstraint(swigCPtr, IntervalVarVector.getCPtr(intervals), name);
    DisjunctiveConstraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new DisjunctiveConstraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DisjunctiveConstraint MakeStrictDisjunctiveConstraint(IntervalVarVector intervals, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeStrictDisjunctiveConstraint(swigCPtr, IntervalVarVector.getCPtr(intervals), name);
    DisjunctiveConstraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new DisjunctiveConstraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals,  long[]  demands, long capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_0(swigCPtr, IntervalVarVector.getCPtr(intervals),  demands.Length, demands , capacity, name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals,  int[]  demands, long capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_1(swigCPtr, IntervalVarVector.getCPtr(intervals),  demands.Length, demands , capacity, name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals,  long[]  demands, IntVar capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_2(swigCPtr, IntervalVarVector.getCPtr(intervals),  demands.Length, demands , IntVar.getCPtr(capacity), name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals,  int[]  demands, IntVar capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_3(swigCPtr, IntervalVarVector.getCPtr(intervals),  demands.Length, demands , IntVar.getCPtr(capacity), name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals, IntVarVector demands, long capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_4(swigCPtr, IntervalVarVector.getCPtr(intervals), IntVarVector.getCPtr(demands), capacity, name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCumulative(IntervalVarVector intervals, IntVarVector demands, IntVar capacity, string name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCumulative__SWIG_5(swigCPtr, IntervalVarVector.getCPtr(intervals), IntVarVector.getCPtr(demands), IntVar.getCPtr(capacity), name);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeCover(IntervalVarVector vars, IntervalVar target_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCover(swigCPtr, IntervalVarVector.getCPtr(vars), IntervalVar.getCPtr(target_var));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Constraint MakeEquality(IntervalVar var1, IntervalVar var2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeEquality__SWIG_3(swigCPtr, IntervalVar.getCPtr(var1), IntervalVar.getCPtr(var2));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Assignment MakeAssignment() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignment__SWIG_0(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  public Assignment MakeAssignment(Assignment a) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignment__SWIG_1(swigCPtr, Assignment.getCPtr(a));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeFirstSolutionCollector(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFirstSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeFirstSolutionCollector() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFirstSolutionCollector__SWIG_1(swigCPtr);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeLastSolutionCollector(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLastSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeLastSolutionCollector() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLastSolutionCollector__SWIG_1(swigCPtr);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeBestValueSolutionCollector(Assignment assignment, bool maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBestValueSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), maximize);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeBestLexicographicValueSolutionCollector(Assignment assignment, SWIGTYPE_p_std__vectorT_bool_t maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBestLexicographicValueSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SolutionCollector MakeBestValueSolutionCollector(bool maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBestValueSolutionCollector__SWIG_1(swigCPtr, maximize);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeBestLexicographicValueSolutionCollector(SWIGTYPE_p_std__vectorT_bool_t maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBestLexicographicValueSolutionCollector__SWIG_1(swigCPtr, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SolutionCollector MakeNBestValueSolutionCollector(Assignment assignment, int solution_count, bool maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNBestValueSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), solution_count, maximize);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeNBestValueSolutionCollector(int solution_count, bool maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNBestValueSolutionCollector__SWIG_1(swigCPtr, solution_count, maximize);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeNBestLexicographicValueSolutionCollector(Assignment assignment, int solution_count, SWIGTYPE_p_std__vectorT_bool_t maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNBestLexicographicValueSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), solution_count, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SolutionCollector MakeNBestLexicographicValueSolutionCollector(int solution_count, SWIGTYPE_p_std__vectorT_bool_t maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNBestLexicographicValueSolutionCollector__SWIG_1(swigCPtr, solution_count, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SolutionCollector MakeAllSolutionCollector(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllSolutionCollector__SWIG_0(swigCPtr, Assignment.getCPtr(assignment));
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public SolutionCollector MakeAllSolutionCollector() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAllSolutionCollector__SWIG_1(swigCPtr);
    SolutionCollector ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionCollector(cPtr, false);
    return ret;
  }
 
  public OptimizeVar MakeMinimize(IntVar v, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMinimize(swigCPtr, IntVar.getCPtr(v), step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    return ret;
  }
 
  public OptimizeVar MakeMaximize(IntVar v, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMaximize(swigCPtr, IntVar.getCPtr(v), step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    return ret;
  }
 
  public OptimizeVar MakeOptimize(bool maximize, IntVar v, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOptimize(swigCPtr, maximize, IntVar.getCPtr(v), step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    return ret;
  }
 
  public OptimizeVar MakeWeightedMinimize(IntVarVector sub_objectives,  long[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedMinimize__SWIG_0(swigCPtr, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeWeightedMinimize(IntVarVector sub_objectives,  int[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedMinimize__SWIG_1(swigCPtr, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeWeightedMaximize(IntVarVector sub_objectives,  long[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedMaximize__SWIG_0(swigCPtr, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeWeightedMaximize(IntVarVector sub_objectives,  int[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedMaximize__SWIG_1(swigCPtr, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeWeightedOptimize(bool maximize, IntVarVector sub_objectives,  long[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedOptimize__SWIG_0(swigCPtr, maximize, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeWeightedOptimize(bool maximize, IntVarVector sub_objectives,  int[]  weights, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeWeightedOptimize__SWIG_1(swigCPtr, maximize, IntVarVector.getCPtr(sub_objectives),  weights.Length, weights , step);
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OptimizeVar MakeLexicographicOptimize(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVarVector variables,  long[]  steps) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicographicOptimize(swigCPtr, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize), IntVarVector.getCPtr(variables),  steps.Length, steps );
    OptimizeVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new OptimizeVar(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public ObjectiveMonitor MakeTabuSearch(bool maximize, IntVar objective, long step, IntVarVector vars, long keep_tenure, long forbid_tenure, double tabu_factor) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTabuSearch(swigCPtr, maximize, IntVar.getCPtr(objective), step, IntVarVector.getCPtr(vars), keep_tenure, forbid_tenure, tabu_factor);
    ObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectiveMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public ObjectiveMonitor MakeLexicographicTabuSearch(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVarVector objectives,  long[]  steps, IntVarVector vars, long keep_tenure, long forbid_tenure, double tabu_factor) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicographicTabuSearch(swigCPtr, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize), IntVarVector.getCPtr(objectives),  steps.Length, steps , IntVarVector.getCPtr(vars), keep_tenure, forbid_tenure, tabu_factor);
    ObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectiveMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public ObjectiveMonitor MakeGenericTabuSearch(bool maximize, IntVar v, long step, IntVarVector tabu_vars, long forbid_tenure) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeGenericTabuSearch(swigCPtr, maximize, IntVar.getCPtr(v), step, IntVarVector.getCPtr(tabu_vars), forbid_tenure);
    ObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectiveMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public ObjectiveMonitor MakeSimulatedAnnealing(bool maximize, IntVar v, long step, long initial_temperature) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSimulatedAnnealing(swigCPtr, maximize, IntVar.getCPtr(v), step, initial_temperature);
    ObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectiveMonitor(cPtr, false);
    return ret;
  }
 
  public ObjectiveMonitor MakeLexicographicSimulatedAnnealing(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVarVector vars,  long[]  steps,  long[]  initial_temperatures) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicographicSimulatedAnnealing(swigCPtr, SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize), IntVarVector.getCPtr(vars),  steps.Length, steps ,  initial_temperatures.Length, initial_temperatures );
    ObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectiveMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public BaseObjectiveMonitor MakeRoundRobinCompoundObjectiveMonitor(SWIGTYPE_p_std__vectorT_operations_research__BaseObjectiveMonitor_p_t monitors, int num_max_local_optima_before_metaheuristic_switch) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRoundRobinCompoundObjectiveMonitor(swigCPtr, SWIGTYPE_p_std__vectorT_operations_research__BaseObjectiveMonitor_p_t.getCPtr(monitors), num_max_local_optima_before_metaheuristic_switch);
    BaseObjectiveMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new BaseObjectiveMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SearchMonitor MakeLubyRestart(int scale_factor) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLubyRestart(swigCPtr, scale_factor);
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeConstantRestart(int frequency) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeConstantRestart(swigCPtr, frequency);
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeTimeLimit(SWIGTYPE_p_absl__Duration time) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTimeLimit__SWIG_0(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(time));
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RegularLimit MakeTimeLimit(long time_in_ms) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeTimeLimit__SWIG_1(swigCPtr, time_in_ms);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeBranchesLimit(long branches) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeBranchesLimit(swigCPtr, branches);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeFailuresLimit(long failures) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFailuresLimit(swigCPtr, failures);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeSolutionsLimit(long solutions) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolutionsLimit(swigCPtr, solutions);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeLimit(SWIGTYPE_p_absl__Duration time, long branches, long failures, long solutions, bool smart_time_check, bool cumulative) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_0(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(time), branches, failures, solutions, smart_time_check, cumulative);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RegularLimit MakeLimit(SWIGTYPE_p_absl__Duration time, long branches, long failures, long solutions, bool smart_time_check) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_1(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(time), branches, failures, solutions, smart_time_check);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RegularLimit MakeLimit(SWIGTYPE_p_absl__Duration time, long branches, long failures, long solutions) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_2(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(time), branches, failures, solutions);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RegularLimit MakeLimit(Google.OrTools.ConstraintSolver.RegularLimitParameters proto) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_3(swigCPtr, ProtoHelper.ProtoToByteArray(proto, out var buffer), buffer);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeLimit(long time, long branches, long failures, long solutions, bool smart_time_check, bool cumulative) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_4(swigCPtr, time, branches, failures, solutions, smart_time_check, cumulative);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeLimit(long time, long branches, long failures, long solutions, bool smart_time_check) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_5(swigCPtr, time, branches, failures, solutions, smart_time_check);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public RegularLimit MakeLimit(long time, long branches, long failures, long solutions) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_6(swigCPtr, time, branches, failures, solutions);
    RegularLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new RegularLimit(cPtr, false);
    return ret;
  }
 
  public Google.OrTools.ConstraintSolver.RegularLimitParameters MakeDefaultRegularLimitParameters() {
  System.IntPtr dataPointer = operations_research_constraint_solverPINVOKE.Solver_MakeDefaultRegularLimitParameters(swigCPtr);
  try
  {
    int size = System.Runtime.InteropServices.Marshal.ReadInt32(dataPointer);
    unsafe
    {
      var data = new System.ReadOnlySpan<byte>((dataPointer + sizeof(int)).ToPointer(), size);
      return Google.OrTools.ConstraintSolver.RegularLimitParameters.Parser.ParseFrom(data);
    }
  } catch (Google.Protobuf.InvalidProtocolBufferException /*e*/)
  {
    throw new System.Exception("Unable to parse Google.OrTools.ConstraintSolver.RegularLimitParameters protocol message.");
  }
  finally
  {
    Google.OrTools.Init.CppBridge.DeleteByteArray(dataPointer);
  }
}
 
  public SearchLimit MakeLimit(SearchLimit limit_1, SearchLimit limit_2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLimit__SWIG_7(swigCPtr, SearchLimit.getCPtr(limit_1), SearchLimit.getCPtr(limit_2));
    SearchLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchLimit(cPtr, false);
    return ret;
  }
 
  public ImprovementSearchLimit MakeImprovementLimit(IntVar objective_var, bool maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeImprovementLimit(swigCPtr, IntVar.getCPtr(objective_var), maximize, objective_scaling_factor, objective_offset, improvement_rate_coefficient, improvement_rate_solutions_distance);
    ImprovementSearchLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new ImprovementSearchLimit(cPtr, false);
    return ret;
  }
 
  public ImprovementSearchLimit MakeLexicographicImprovementLimit(IntVarVector objective_vars, SWIGTYPE_p_std__vectorT_bool_t maximize, SWIGTYPE_p_std__vectorT_double_t objective_scaling_factors, SWIGTYPE_p_std__vectorT_double_t objective_offsets, double improvement_rate_coefficient, int improvement_rate_solutions_distance) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLexicographicImprovementLimit(swigCPtr, IntVarVector.getCPtr(objective_vars), SWIGTYPE_p_std__vectorT_bool_t.getCPtr(maximize), SWIGTYPE_p_std__vectorT_double_t.getCPtr(objective_scaling_factors), SWIGTYPE_p_std__vectorT_double_t.getCPtr(objective_offsets), improvement_rate_coefficient, improvement_rate_solutions_distance);
    ImprovementSearchLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new ImprovementSearchLimit(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SearchLimit MakeCustomLimit( VoidToBoolean  limiter) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeCustomLimit(swigCPtr,  StoreVoidToBoolean(limiter) );
    SearchLimit ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchLimit(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_0(swigCPtr, branch_period);
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period, IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_1(swigCPtr, branch_period, IntVar.getCPtr(var));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period,  VoidToString  display_callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_2(swigCPtr, branch_period,  StoreVoidToString(display_callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period, IntVar var,  VoidToString  display_callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_3(swigCPtr, branch_period, IntVar.getCPtr(var),  StoreVoidToString(display_callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period, IntVarVector vars,  VoidToString  display_callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_4(swigCPtr, branch_period, IntVarVector.getCPtr(vars),  StoreVoidToString(display_callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period, OptimizeVar opt_var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_5(swigCPtr, branch_period, OptimizeVar.getCPtr(opt_var));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchLog(int branch_period, OptimizeVar opt_var,  VoidToString  display_callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchLog__SWIG_6(swigCPtr, branch_period, OptimizeVar.getCPtr(opt_var),  StoreVoidToString(display_callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSearchTrace(string prefix) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSearchTrace(swigCPtr, prefix);
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SearchMonitor MakeEnterSearchCallback( VoidToVoid  callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeEnterSearchCallback(swigCPtr,  StoreVoidToVoid(callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeExitSearchCallback( VoidToVoid  callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeExitSearchCallback(swigCPtr,  StoreVoidToVoid(callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeAtSolutionCallback( VoidToVoid  callback) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAtSolutionCallback(swigCPtr,  StoreVoidToVoid(callback) );
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public ModelVisitor MakePrintModelVisitor() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePrintModelVisitor(swigCPtr);
    ModelVisitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ModelVisitor(cPtr, false);
    return ret;
  }
 
  public ModelVisitor MakeStatisticsModelVisitor() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeStatisticsModelVisitor(swigCPtr);
    ModelVisitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new ModelVisitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSymmetryManager(SymmetryBreakerVector visitors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSymmetryManager__SWIG_0(swigCPtr, SymmetryBreakerVector.getCPtr(visitors));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SearchMonitor MakeSymmetryManager(SymmetryBreaker v1) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSymmetryManager__SWIG_1(swigCPtr, SymmetryBreaker.getCPtr(v1));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSymmetryManager(SymmetryBreaker v1, SymmetryBreaker v2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSymmetryManager__SWIG_2(swigCPtr, SymmetryBreaker.getCPtr(v1), SymmetryBreaker.getCPtr(v2));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSymmetryManager(SymmetryBreaker v1, SymmetryBreaker v2, SymmetryBreaker v3) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSymmetryManager__SWIG_3(swigCPtr, SymmetryBreaker.getCPtr(v1), SymmetryBreaker.getCPtr(v2), SymmetryBreaker.getCPtr(v3));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public SearchMonitor MakeSymmetryManager(SymmetryBreaker v1, SymmetryBreaker v2, SymmetryBreaker v3, SymmetryBreaker v4) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSymmetryManager__SWIG_4(swigCPtr, SymmetryBreaker.getCPtr(v1), SymmetryBreaker.getCPtr(v2), SymmetryBreaker.getCPtr(v3), SymmetryBreaker.getCPtr(v4));
    SearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new SearchMonitor(cPtr, false);
    return ret;
  }
 
  public Decision MakeAssignVariableValue(IntVar var, long val) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariableValue(swigCPtr, IntVar.getCPtr(var), val);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeVariableLessOrEqualValue(IntVar var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeVariableLessOrEqualValue(swigCPtr, IntVar.getCPtr(var), value);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeVariableGreaterOrEqualValue(IntVar var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeVariableGreaterOrEqualValue(swigCPtr, IntVar.getCPtr(var), value);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeSplitVariableDomain(IntVar var, long val, bool start_with_lower_half) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSplitVariableDomain(swigCPtr, IntVar.getCPtr(var), val, start_with_lower_half);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeAssignVariableValueOrFail(IntVar var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariableValueOrFail(swigCPtr, IntVar.getCPtr(var), value);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeAssignVariableValueOrDoNothing(IntVar var, long value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariableValueOrDoNothing(swigCPtr, IntVar.getCPtr(var), value);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeAssignVariablesValues(IntVarVector vars,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariablesValues(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values );
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Decision MakeAssignVariablesValuesOrDoNothing(IntVarVector vars,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariablesValuesOrDoNothing(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values );
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Decision MakeAssignVariablesValuesOrFail(IntVarVector vars,  long[]  values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAssignVariablesValuesOrFail(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values );
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Decision MakeFailDecision() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeFailDecision(swigCPtr);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeDecision( SolverToVoid  apply,  SolverToVoid  refute) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDecision(swigCPtr,  StoreSolverToVoid(apply) ,  StoreSolverToVoid(refute) );
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Compose(DecisionBuilder db1, DecisionBuilder db2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Compose__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Compose(DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Compose__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2), DecisionBuilder.getCPtr(db3));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Compose(DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3, DecisionBuilder db4) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Compose__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2), DecisionBuilder.getCPtr(db3), DecisionBuilder.getCPtr(db4));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Compose(DecisionBuilderVector dbs) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Compose__SWIG_3(swigCPtr, DecisionBuilderVector.getCPtr(dbs));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder Try(DecisionBuilder db1, DecisionBuilder db2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Try__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Try(DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Try__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2), DecisionBuilder.getCPtr(db3));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Try(DecisionBuilder db1, DecisionBuilder db2, DecisionBuilder db3, DecisionBuilder db4) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Try__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db1), DecisionBuilder.getCPtr(db2), DecisionBuilder.getCPtr(db3), DecisionBuilder.getCPtr(db4));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder Try(DecisionBuilderVector dbs) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Try__SWIG_3(swigCPtr, DecisionBuilderVector.getCPtr(dbs));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars, int var_str, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), var_str, val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars,  LongToLong  var_evaluator, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongToLong(var_evaluator) , val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars, int var_str,  LongLongToLong  value_evaluator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars), var_str,  StoreLongLongToLong(value_evaluator) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars, int var_str,  LongLongLongToBoolean  var_val1_val2_comparator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_3(swigCPtr, IntVarVector.getCPtr(vars), var_str,  StoreLongLongLongToBoolean(var_val1_val2_comparator) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars,  LongToLong  var_evaluator,  LongLongToLong  value_evaluator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_4(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongToLong(var_evaluator) ,  StoreLongLongToLong(value_evaluator) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars, int var_str,  LongLongToLong  value_evaluator,  LongToLong  tie_breaker) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_5(swigCPtr, IntVarVector.getCPtr(vars), var_str,  StoreLongLongToLong(value_evaluator) ,  StoreLongToLong(tie_breaker) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars,  LongToLong  var_evaluator,  LongLongToLong  value_evaluator,  LongToLong  tie_breaker) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_6(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongToLong(var_evaluator) ,  StoreLongLongToLong(value_evaluator) ,  StoreLongToLong(tie_breaker) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeDefaultPhase(IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDefaultPhase__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeDefaultPhase(IntVarVector vars, DefaultPhaseParameters parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDefaultPhase__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), DefaultPhaseParameters.getCPtr(parameters));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVar v0, int var_str, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_7(swigCPtr, IntVar.getCPtr(v0), var_str, val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVar v0, IntVar v1, int var_str, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_8(swigCPtr, IntVar.getCPtr(v0), IntVar.getCPtr(v1), var_str, val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVar v0, IntVar v1, IntVar v2, int var_str, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_9(swigCPtr, IntVar.getCPtr(v0), IntVar.getCPtr(v1), IntVar.getCPtr(v2), var_str, val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVar v0, IntVar v1, IntVar v2, IntVar v3, int var_str, int val_str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_10(swigCPtr, IntVar.getCPtr(v0), IntVar.getCPtr(v1), IntVar.getCPtr(v2), IntVar.getCPtr(v3), var_str, val_str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public Decision MakeScheduleOrPostpone(IntervalVar var, long est, ref int marker) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScheduleOrPostpone(swigCPtr, IntervalVar.getCPtr(var), est, ref marker);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeScheduleOrExpedite(IntervalVar var, long est, ref int marker) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeScheduleOrExpedite(swigCPtr, IntervalVar.getCPtr(var), est, ref marker);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeRankFirstInterval(SequenceVar sequence, int index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRankFirstInterval(swigCPtr, SequenceVar.getCPtr(sequence), index);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public Decision MakeRankLastInterval(SequenceVar sequence, int index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRankLastInterval(swigCPtr, SequenceVar.getCPtr(sequence), index);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars,  LongLongToLong  eval, int str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_11(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongLongToLong(eval) , str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntVarVector vars,  LongLongToLong  eval,  LongToLong  tie_breaker, int str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_12(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongLongToLong(eval) ,  StoreLongToLong(tie_breaker) , str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(IntervalVarVector intervals, int str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_13(swigCPtr, IntervalVarVector.getCPtr(intervals), str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakePhase(SequenceVarVector sequences, int str) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakePhase__SWIG_14(swigCPtr, SequenceVarVector.getCPtr(sequences), str);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeDecisionBuilderFromAssignment(Assignment assignment, DecisionBuilder db, IntVarVector vars) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDecisionBuilderFromAssignment(swigCPtr, Assignment.getCPtr(assignment), DecisionBuilder.getCPtr(db), IntVarVector.getCPtr(vars));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeConstraintAdder(Constraint ct) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeConstraintAdder(swigCPtr, Constraint.getCPtr(ct));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db, SearchMonitor monitor1) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(monitor1));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db, SearchMonitor monitor1, SearchMonitor monitor2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_3(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2), SearchMonitor.getCPtr(monitor3));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3, SearchMonitor monitor4) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_4(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2), SearchMonitor.getCPtr(monitor3), SearchMonitor.getCPtr(monitor4));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeSolveOnce(DecisionBuilder db, SearchMonitorVector monitors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSolveOnce__SWIG_5(swigCPtr, DecisionBuilder.getCPtr(db), SearchMonitorVector.getCPtr(monitors));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_0(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step);
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step, SearchMonitor monitor1) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_1(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step, SearchMonitor.getCPtr(monitor1));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step, SearchMonitor monitor1, SearchMonitor monitor2) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_2(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step, SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_3(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step, SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2), SearchMonitor.getCPtr(monitor3));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step, SearchMonitor monitor1, SearchMonitor monitor2, SearchMonitor monitor3, SearchMonitor monitor4) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_4(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step, SearchMonitor.getCPtr(monitor1), SearchMonitor.getCPtr(monitor2), SearchMonitor.getCPtr(monitor3), SearchMonitor.getCPtr(monitor4));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeNestedOptimize(DecisionBuilder db, Assignment solution, bool maximize, long step, SearchMonitorVector monitors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNestedOptimize__SWIG_5(swigCPtr, DecisionBuilder.getCPtr(db), Assignment.getCPtr(solution), maximize, step, SearchMonitorVector.getCPtr(monitors));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeRestoreAssignment(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRestoreAssignment(swigCPtr, Assignment.getCPtr(assignment));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeStoreAssignment(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeStoreAssignment(swigCPtr, Assignment.getCPtr(assignment));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_outgoing_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_incoming_neighbors), SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_outgoing_neighbors));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_incoming_neighbors));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, int op) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars), op);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, IntVarVector secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_outgoing_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_3(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(secondary_vars), op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_incoming_neighbors), SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_outgoing_neighbors));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, IntVarVector secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_4(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(secondary_vars), op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t.getCPtr(get_incoming_neighbors));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, IntVarVector secondary_vars, int op) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_5(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(secondary_vars), op);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars,  LongLongLongToLong  evaluator, int op) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_6(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongLongLongToLong(evaluator) , op);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeOperator(IntVarVector vars, IntVarVector secondary_vars,  LongLongLongToLong  evaluator, int op) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeOperator__SWIG_7(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(secondary_vars),  StoreLongLongLongToLong(evaluator) , op);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeRandomLnsOperator(IntVarVector vars, int number_of_variables) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRandomLnsOperator__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars), number_of_variables);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeRandomLnsOperator(IntVarVector vars, int number_of_variables, int seed) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRandomLnsOperator__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), number_of_variables, seed);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeMoveTowardTargetOperator(Assignment target) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMoveTowardTargetOperator__SWIG_0(swigCPtr, Assignment.getCPtr(target));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeMoveTowardTargetOperator(IntVarVector variables,  long[]  target_values) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeMoveTowardTargetOperator__SWIG_1(swigCPtr, IntVarVector.getCPtr(variables),  target_values.Length, target_values );
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator ConcatenateOperators(LocalSearchOperatorVector ops) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_ConcatenateOperators__SWIG_0(swigCPtr, LocalSearchOperatorVector.getCPtr(ops));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator ConcatenateOperators(LocalSearchOperatorVector ops, bool restart) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_ConcatenateOperators__SWIG_1(swigCPtr, LocalSearchOperatorVector.getCPtr(ops), restart);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator ConcatenateOperators(LocalSearchOperatorVector ops,  IntIntToLong  evaluator) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_ConcatenateOperators__SWIG_2(swigCPtr, LocalSearchOperatorVector.getCPtr(ops),  StoreIntIntToLong(evaluator) );
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator RandomConcatenateOperators(LocalSearchOperatorVector ops) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RandomConcatenateOperators__SWIG_0(swigCPtr, LocalSearchOperatorVector.getCPtr(ops));
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator RandomConcatenateOperators(LocalSearchOperatorVector ops, int seed) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RandomConcatenateOperators__SWIG_1(swigCPtr, LocalSearchOperatorVector.getCPtr(ops), seed);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MultiArmedBanditConcatenateOperators(LocalSearchOperatorVector ops, double memory_coefficient, double exploration_coefficient, bool maximize) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MultiArmedBanditConcatenateOperators(swigCPtr, LocalSearchOperatorVector.getCPtr(ops), memory_coefficient, exploration_coefficient, maximize);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public LocalSearchOperator MakeNeighborhoodLimit(LocalSearchOperator op, long limit) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeNeighborhoodLimit(swigCPtr, LocalSearchOperator.getCPtr(op), limit);
    LocalSearchOperator ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchOperator(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeLocalSearchPhase(Assignment assignment, LocalSearchPhaseParameters parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhase__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), LocalSearchPhaseParameters.getCPtr(parameters));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public DecisionBuilder MakeLocalSearchPhase(IntVarVector vars, DecisionBuilder first_solution, LocalSearchPhaseParameters parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhase__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), DecisionBuilder.getCPtr(first_solution), LocalSearchPhaseParameters.getCPtr(parameters));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeLocalSearchPhase(IntVarVector vars, DecisionBuilder first_solution, DecisionBuilder first_solution_sub_decision_builder, LocalSearchPhaseParameters parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhase__SWIG_2(swigCPtr, IntVarVector.getCPtr(vars), DecisionBuilder.getCPtr(first_solution), DecisionBuilder.getCPtr(first_solution_sub_decision_builder), LocalSearchPhaseParameters.getCPtr(parameters));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public DecisionBuilder MakeLocalSearchPhase(SequenceVarVector vars, DecisionBuilder first_solution, LocalSearchPhaseParameters parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhase__SWIG_3(swigCPtr, SequenceVarVector.getCPtr(vars), DecisionBuilder.getCPtr(first_solution), LocalSearchPhaseParameters.getCPtr(parameters));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Assignment RunUncheckedLocalSearch(Assignment initial_solution, LocalSearchFilterManager filter_manager, LocalSearchOperator ls_operator, SearchMonitorVector monitors, RegularLimit limit, SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t touched) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RunUncheckedLocalSearch__SWIG_0(swigCPtr, Assignment.getCPtr(initial_solution), LocalSearchFilterManager.getCPtr(filter_manager), LocalSearchOperator.getCPtr(ls_operator), SearchMonitorVector.getCPtr(monitors), RegularLimit.getCPtr(limit), SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t.getCPtr(touched));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public Assignment RunUncheckedLocalSearch(Assignment initial_solution, LocalSearchFilterManager filter_manager, LocalSearchOperator ls_operator, SearchMonitorVector monitors, RegularLimit limit) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RunUncheckedLocalSearch__SWIG_1(swigCPtr, Assignment.getCPtr(initial_solution), LocalSearchFilterManager.getCPtr(filter_manager), LocalSearchOperator.getCPtr(ls_operator), SearchMonitorVector.getCPtr(monitors), RegularLimit.getCPtr(limit));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SolutionPool MakeDefaultSolutionPool() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeDefaultSolutionPool(swigCPtr);
    SolutionPool ret = (cPtr == global::System.IntPtr.Zero) ? null : new SolutionPool(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_0(swigCPtr, IntVar.getCPtr(objective), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_1(swigCPtr, IntVar.getCPtr(objective), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder), RegularLimit.getCPtr(limit));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager filter_manager) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_2(swigCPtr, IntVar.getCPtr(objective), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder), RegularLimit.getCPtr(limit), LocalSearchFilterManager.getCPtr(filter_manager));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_3(swigCPtr, IntVar.getCPtr(objective), SolutionPool.getCPtr(pool), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_4(swigCPtr, IntVar.getCPtr(objective), SolutionPool.getCPtr(pool), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder), RegularLimit.getCPtr(limit));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchPhaseParameters MakeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager filter_manager) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeLocalSearchPhaseParameters__SWIG_5(swigCPtr, IntVar.getCPtr(objective), SolutionPool.getCPtr(pool), LocalSearchOperator.getCPtr(ls_operator), DecisionBuilder.getCPtr(sub_decision_builder), RegularLimit.getCPtr(limit), LocalSearchFilterManager.getCPtr(filter_manager));
    LocalSearchPhaseParameters ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchPhaseParameters(cPtr, false);
    return ret;
  }
 
  public LocalSearchFilter MakeAcceptFilter() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeAcceptFilter(swigCPtr);
    LocalSearchFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchFilter(cPtr, false);
    return ret;
  }
 
  public LocalSearchFilter MakeRejectFilter() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeRejectFilter(swigCPtr);
    LocalSearchFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchFilter(cPtr, false);
    return ret;
  }
 
  public LocalSearchFilter MakeVariableDomainFilter() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeVariableDomainFilter(swigCPtr);
    LocalSearchFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchFilter(cPtr, false);
    return ret;
  }
 
  public IntVarLocalSearchFilter MakeSumObjectiveFilter(IntVarVector vars,  LongLongToLong  values, int filter_enum) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumObjectiveFilter__SWIG_0(swigCPtr, IntVarVector.getCPtr(vars),  StoreLongLongToLong(values) , filter_enum);
    IntVarLocalSearchFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVarLocalSearchFilter(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public IntVarLocalSearchFilter MakeSumObjectiveFilter(IntVarVector vars, IntVarVector secondary_vars,  LongLongLongToLong  values, int filter_enum) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeSumObjectiveFilter__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars), IntVarVector.getCPtr(secondary_vars),  StoreLongLongLongToLong(values) , filter_enum);
    IntVarLocalSearchFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVarLocalSearchFilter(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void TopPeriodicCheck() {
    operations_research_constraint_solverPINVOKE.Solver_TopPeriodicCheck(swigCPtr);
  }
 
  public int TopProgressPercent() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_TopProgressPercent(swigCPtr);
    return ret;
  }
 
  public void PushState() {
    operations_research_constraint_solverPINVOKE.Solver_PushState(swigCPtr);
  }
 
  public void PopState() {
    operations_research_constraint_solverPINVOKE.Solver_PopState(swigCPtr);
  }
 
  public int SearchDepth() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_SearchDepth(swigCPtr);
    return ret;
  }
 
  public int SearchLeftDepth() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_SearchLeftDepth(swigCPtr);
    return ret;
  }
 
  public int SolveDepth() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_SolveDepth(swigCPtr);
    return ret;
  }
 
  public long Rand64(long size) {
    long ret = operations_research_constraint_solverPINVOKE.Solver_Rand64(swigCPtr, size);
    return ret;
  }
 
  public int Rand32(int size) {
    int ret = operations_research_constraint_solverPINVOKE.Solver_Rand32(swigCPtr, size);
    return ret;
  }
 
  public void ReSeed(int seed) {
    operations_research_constraint_solverPINVOKE.Solver_ReSeed(swigCPtr, seed);
  }
 
  public void ExportProfilingOverview(string filename) {
    operations_research_constraint_solverPINVOKE.Solver_ExportProfilingOverview(swigCPtr, filename);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public string LocalSearchProfile() {
    string ret = operations_research_constraint_solverPINVOKE.Solver_LocalSearchProfile(swigCPtr);
    return ret;
  }
 
  public bool CurrentlyInSolve() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_CurrentlyInSolve(swigCPtr);
    return ret;
  }
 
  public int Constraints() {
    int ret = operations_research_constraint_solverPINVOKE.Solver_Constraints(swigCPtr);
    return ret;
  }
 
  public void Accept(ModelVisitor visitor) {
    operations_research_constraint_solverPINVOKE.Solver_Accept(swigCPtr, ModelVisitor.getCPtr(visitor));
  }
 
  public Decision BalancingDecision() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_BalancingDecision(swigCPtr);
    Decision ret = (cPtr == global::System.IntPtr.Zero) ? null : new Decision(cPtr, false);
    return ret;
  }
 
  public void ClearFailIntercept() {
    operations_research_constraint_solverPINVOKE.Solver_ClearFailIntercept(swigCPtr);
  }
 
  public void SetUseFastLocalSearch(bool use_fast_local_search) {
    operations_research_constraint_solverPINVOKE.Solver_SetUseFastLocalSearch(swigCPtr, use_fast_local_search);
  }
 
  public bool UseFastLocalSearch() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_UseFastLocalSearch(swigCPtr);
    return ret;
  }
 
  public bool HasName(PropagationBaseObject object_) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_HasName(swigCPtr, PropagationBaseObject.getCPtr(object_));
    return ret;
  }
 
  public Demon RegisterDemon(Demon demon) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RegisterDemon(swigCPtr, Demon.getCPtr(demon));
    Demon ret = (cPtr == global::System.IntPtr.Zero) ? null : new Demon(cPtr, false);
    return ret;
  }
 
  public IntExpr RegisterIntExpr(IntExpr expr) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RegisterIntExpr(swigCPtr, IntExpr.getCPtr(expr));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public IntVar RegisterIntVar(IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RegisterIntVar(swigCPtr, IntVar.getCPtr(var));
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar RegisterIntervalVar(IntervalVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_RegisterIntervalVar(swigCPtr, IntervalVar.getCPtr(var));
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public ModelCache Cache() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_Cache(swigCPtr);
    ModelCache ret = (cPtr == global::System.IntPtr.Zero) ? null : new ModelCache(cPtr, false);
    return ret;
  }
 
  public bool InstrumentsDemons() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_InstrumentsDemons(swigCPtr);
    return ret;
  }
 
  public bool IsProfilingEnabled() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_IsProfilingEnabled(swigCPtr);
    return ret;
  }
 
  public bool IsLocalSearchProfilingEnabled() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_IsLocalSearchProfilingEnabled(swigCPtr);
    return ret;
  }
 
  public bool InstrumentsVariables() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_InstrumentsVariables(swigCPtr);
    return ret;
  }
 
  public bool NameAllVariables() {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_NameAllVariables(swigCPtr);
    return ret;
  }
 
  public string ModelName() {
    string ret = operations_research_constraint_solverPINVOKE.Solver_ModelName(swigCPtr);
    return ret;
  }
 
  public PropagationMonitor GetPropagationMonitor() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_GetPropagationMonitor(swigCPtr);
    PropagationMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropagationMonitor(cPtr, false);
    return ret;
  }
 
  public void AddPropagationMonitor(PropagationMonitor monitor) {
    operations_research_constraint_solverPINVOKE.Solver_AddPropagationMonitor(swigCPtr, PropagationMonitor.getCPtr(monitor));
  }
 
  public LocalSearchMonitor GetLocalSearchMonitor() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_GetLocalSearchMonitor(swigCPtr);
    LocalSearchMonitor ret = (cPtr == global::System.IntPtr.Zero) ? null : new LocalSearchMonitor(cPtr, false);
    return ret;
  }
 
  public void AddLocalSearchMonitor(LocalSearchMonitor monitor) {
    operations_research_constraint_solverPINVOKE.Solver_AddLocalSearchMonitor(swigCPtr, LocalSearchMonitor.getCPtr(monitor));
  }
 
  public bool AcceptSolution(SWIGTYPE_p_operations_research__Search search) {
    bool ret = operations_research_constraint_solverPINVOKE.Solver_AcceptSolution(swigCPtr, SWIGTYPE_p_operations_research__Search.getCPtr(search));
    return ret;
  }
 
  public Assignment GetOrCreateLocalSearchState() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_GetOrCreateLocalSearchState(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  public void ClearLocalSearchState() {
    operations_research_constraint_solverPINVOKE.Solver_ClearLocalSearchState(swigCPtr);
  }
 
  public IntExpr CastExpression(IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_CastExpression(swigCPtr, IntVar.getCPtr(var));
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public void FinishCurrentSearch() {
    operations_research_constraint_solverPINVOKE.Solver_FinishCurrentSearch(swigCPtr);
  }
 
  public void RestartCurrentSearch() {
    operations_research_constraint_solverPINVOKE.Solver_RestartCurrentSearch(swigCPtr);
  }
 
  public void ShouldFail() {
    operations_research_constraint_solverPINVOKE.Solver_ShouldFail(swigCPtr);
  }
 
  public void CheckFail() {
    operations_research_constraint_solverPINVOKE.Solver_CheckFail(swigCPtr);
  }
 
  public DecisionBuilder MakeProfiledDecisionBuilderWrapper(DecisionBuilder db) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Solver_MakeProfiledDecisionBuilderWrapper(swigCPtr, DecisionBuilder.getCPtr(db));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }
 
  public static readonly int kNumPriorities = operations_research_constraint_solverPINVOKE.Solver_kNumPriorities_get();
  // IntVarStrategy 
  public static readonly int INT_VAR_DEFAULT = operations_research_constraint_solverPINVOKE.Solver_INT_VAR_DEFAULT_get();
  public static readonly int INT_VAR_SIMPLE = operations_research_constraint_solverPINVOKE.Solver_INT_VAR_SIMPLE_get();
  public static readonly int CHOOSE_FIRST_UNBOUND = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_FIRST_UNBOUND_get();
  public static readonly int CHOOSE_RANDOM = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_RANDOM_get();
  public static readonly int CHOOSE_MIN_SIZE_LOWEST_MIN = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN_get();
  public static readonly int CHOOSE_MIN_SIZE_HIGHEST_MIN = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN_get();
  public static readonly int CHOOSE_MIN_SIZE_LOWEST_MAX = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX_get();
  public static readonly int CHOOSE_MIN_SIZE_HIGHEST_MAX = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX_get();
  public static readonly int CHOOSE_LOWEST_MIN = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_LOWEST_MIN_get();
  public static readonly int CHOOSE_HIGHEST_MAX = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_HIGHEST_MAX_get();
  public static readonly int CHOOSE_MIN_SIZE = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SIZE_get();
  public static readonly int CHOOSE_MAX_SIZE = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MAX_SIZE_get();
  public static readonly int CHOOSE_MAX_REGRET_ON_MIN = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MAX_REGRET_ON_MIN_get();
  public static readonly int CHOOSE_PATH = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_PATH_get();
 
  // IntValueStrategy 
  public static readonly int INT_VALUE_DEFAULT = operations_research_constraint_solverPINVOKE.Solver_INT_VALUE_DEFAULT_get();
  public static readonly int INT_VALUE_SIMPLE = operations_research_constraint_solverPINVOKE.Solver_INT_VALUE_SIMPLE_get();
  public static readonly int ASSIGN_MIN_VALUE = operations_research_constraint_solverPINVOKE.Solver_ASSIGN_MIN_VALUE_get();
  public static readonly int ASSIGN_MAX_VALUE = operations_research_constraint_solverPINVOKE.Solver_ASSIGN_MAX_VALUE_get();
  public static readonly int ASSIGN_RANDOM_VALUE = operations_research_constraint_solverPINVOKE.Solver_ASSIGN_RANDOM_VALUE_get();
  public static readonly int ASSIGN_CENTER_VALUE = operations_research_constraint_solverPINVOKE.Solver_ASSIGN_CENTER_VALUE_get();
  public static readonly int SPLIT_LOWER_HALF = operations_research_constraint_solverPINVOKE.Solver_SPLIT_LOWER_HALF_get();
  public static readonly int SPLIT_UPPER_HALF = operations_research_constraint_solverPINVOKE.Solver_SPLIT_UPPER_HALF_get();
 
  // EvaluatorStrategy 
  public static readonly int CHOOSE_STATIC_GLOBAL_BEST = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_STATIC_GLOBAL_BEST_get();
  public static readonly int CHOOSE_DYNAMIC_GLOBAL_BEST = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_DYNAMIC_GLOBAL_BEST_get();
 
  // SequenceStrategy 
  public static readonly int SEQUENCE_DEFAULT = operations_research_constraint_solverPINVOKE.Solver_SEQUENCE_DEFAULT_get();
  public static readonly int SEQUENCE_SIMPLE = operations_research_constraint_solverPINVOKE.Solver_SEQUENCE_SIMPLE_get();
  public static readonly int CHOOSE_MIN_SLACK_RANK_FORWARD = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD_get();
  public static readonly int CHOOSE_RANDOM_RANK_FORWARD = operations_research_constraint_solverPINVOKE.Solver_CHOOSE_RANDOM_RANK_FORWARD_get();
 
  // IntervalStrategy 
  public static readonly int INTERVAL_DEFAULT = operations_research_constraint_solverPINVOKE.Solver_INTERVAL_DEFAULT_get();
  public static readonly int INTERVAL_SIMPLE = operations_research_constraint_solverPINVOKE.Solver_INTERVAL_SIMPLE_get();
  public static readonly int INTERVAL_SET_TIMES_FORWARD = operations_research_constraint_solverPINVOKE.Solver_INTERVAL_SET_TIMES_FORWARD_get();
  public static readonly int INTERVAL_SET_TIMES_BACKWARD = operations_research_constraint_solverPINVOKE.Solver_INTERVAL_SET_TIMES_BACKWARD_get();
 
  // LocalSearchOperators 
  public static readonly int TWOOPT = operations_research_constraint_solverPINVOKE.Solver_TWOOPT_get();
  public static readonly int OROPT = operations_research_constraint_solverPINVOKE.Solver_OROPT_get();
  public static readonly int RELOCATE = operations_research_constraint_solverPINVOKE.Solver_RELOCATE_get();
  public static readonly int EXCHANGE = operations_research_constraint_solverPINVOKE.Solver_EXCHANGE_get();
  public static readonly int CROSS = operations_research_constraint_solverPINVOKE.Solver_CROSS_get();
  public static readonly int MAKEACTIVE = operations_research_constraint_solverPINVOKE.Solver_MAKEACTIVE_get();
  public static readonly int MAKEINACTIVE = operations_research_constraint_solverPINVOKE.Solver_MAKEINACTIVE_get();
  public static readonly int MAKECHAININACTIVE = operations_research_constraint_solverPINVOKE.Solver_MAKECHAININACTIVE_get();
  public static readonly int SWAPACTIVE = operations_research_constraint_solverPINVOKE.Solver_SWAPACTIVE_get();
  public static readonly int SWAPACTIVECHAIN = operations_research_constraint_solverPINVOKE.Solver_SWAPACTIVECHAIN_get();
  public static readonly int EXTENDEDSWAPACTIVE = operations_research_constraint_solverPINVOKE.Solver_EXTENDEDSWAPACTIVE_get();
  public static readonly int PATHLNS = operations_research_constraint_solverPINVOKE.Solver_PATHLNS_get();
  public static readonly int FULLPATHLNS = operations_research_constraint_solverPINVOKE.Solver_FULLPATHLNS_get();
  public static readonly int UNACTIVELNS = operations_research_constraint_solverPINVOKE.Solver_UNACTIVELNS_get();
  public static readonly int INCREMENT = operations_research_constraint_solverPINVOKE.Solver_INCREMENT_get();
  public static readonly int DECREMENT = operations_research_constraint_solverPINVOKE.Solver_DECREMENT_get();
  public static readonly int SIMPLELNS = operations_research_constraint_solverPINVOKE.Solver_SIMPLELNS_get();
 
  // EvaluatorLocalSearchOperators 
  public static readonly int LK = operations_research_constraint_solverPINVOKE.Solver_LK_get();
  public static readonly int TSPOPT = operations_research_constraint_solverPINVOKE.Solver_TSPOPT_get();
  public static readonly int TSPLNS = operations_research_constraint_solverPINVOKE.Solver_TSPLNS_get();
 
  // LocalSearchFilterBound 
  public static readonly int GE = operations_research_constraint_solverPINVOKE.Solver_GE_get();
  public static readonly int LE = operations_research_constraint_solverPINVOKE.Solver_LE_get();
  public static readonly int EQ = operations_research_constraint_solverPINVOKE.Solver_EQ_get();
 
  // DemonPriority 
  public static readonly int DELAYED_PRIORITY = operations_research_constraint_solverPINVOKE.Solver_DELAYED_PRIORITY_get();
  public static readonly int VAR_PRIORITY = operations_research_constraint_solverPINVOKE.Solver_VAR_PRIORITY_get();
  public static readonly int NORMAL_PRIORITY = operations_research_constraint_solverPINVOKE.Solver_NORMAL_PRIORITY_get();
 
  // BinaryIntervalRelation 
  public static readonly int ENDS_AFTER_END = operations_research_constraint_solverPINVOKE.Solver_ENDS_AFTER_END_get();
  public static readonly int ENDS_AFTER_START = operations_research_constraint_solverPINVOKE.Solver_ENDS_AFTER_START_get();
  public static readonly int ENDS_AT_END = operations_research_constraint_solverPINVOKE.Solver_ENDS_AT_END_get();
  public static readonly int ENDS_AT_START = operations_research_constraint_solverPINVOKE.Solver_ENDS_AT_START_get();
  public static readonly int STARTS_AFTER_END = operations_research_constraint_solverPINVOKE.Solver_STARTS_AFTER_END_get();
  public static readonly int STARTS_AFTER_START = operations_research_constraint_solverPINVOKE.Solver_STARTS_AFTER_START_get();
  public static readonly int STARTS_AT_END = operations_research_constraint_solverPINVOKE.Solver_STARTS_AT_END_get();
  public static readonly int STARTS_AT_START = operations_research_constraint_solverPINVOKE.Solver_STARTS_AT_START_get();
  public static readonly int STAYS_IN_SYNC = operations_research_constraint_solverPINVOKE.Solver_STAYS_IN_SYNC_get();
 
  // UnaryIntervalRelation 
  public static readonly int ENDS_AFTER = operations_research_constraint_solverPINVOKE.Solver_ENDS_AFTER_get();
  public static readonly int ENDS_AT = operations_research_constraint_solverPINVOKE.Solver_ENDS_AT_get();
  public static readonly int ENDS_BEFORE = operations_research_constraint_solverPINVOKE.Solver_ENDS_BEFORE_get();
  public static readonly int STARTS_AFTER = operations_research_constraint_solverPINVOKE.Solver_STARTS_AFTER_get();
  public static readonly int STARTS_AT = operations_research_constraint_solverPINVOKE.Solver_STARTS_AT_get();
  public static readonly int STARTS_BEFORE = operations_research_constraint_solverPINVOKE.Solver_STARTS_BEFORE_get();
  public static readonly int CROSS_DATE = operations_research_constraint_solverPINVOKE.Solver_CROSS_DATE_get();
  public static readonly int AVOID_DATE = operations_research_constraint_solverPINVOKE.Solver_AVOID_DATE_get();
 
  // DecisionModification 
  public static readonly int NO_CHANGE = operations_research_constraint_solverPINVOKE.Solver_NO_CHANGE_get();
  public static readonly int KEEP_LEFT = operations_research_constraint_solverPINVOKE.Solver_KEEP_LEFT_get();
  public static readonly int KEEP_RIGHT = operations_research_constraint_solverPINVOKE.Solver_KEEP_RIGHT_get();
  public static readonly int KILL_BOTH = operations_research_constraint_solverPINVOKE.Solver_KILL_BOTH_get();
  public static readonly int SWITCH_BRANCHES = operations_research_constraint_solverPINVOKE.Solver_SWITCH_BRANCHES_get();
 
  // MarkerType 
  public static readonly int SENTINEL = operations_research_constraint_solverPINVOKE.Solver_SENTINEL_get();
  public static readonly int SIMPLE_MARKER = operations_research_constraint_solverPINVOKE.Solver_SIMPLE_MARKER_get();
  public static readonly int CHOICE_POINT = operations_research_constraint_solverPINVOKE.Solver_CHOICE_POINT_get();
  public static readonly int REVERSIBLE_ACTION = operations_research_constraint_solverPINVOKE.Solver_REVERSIBLE_ACTION_get();
 
  // SolverState 
  public static readonly int OUTSIDE_SEARCH = operations_research_constraint_solverPINVOKE.Solver_OUTSIDE_SEARCH_get();
  public static readonly int IN_ROOT_NODE = operations_research_constraint_solverPINVOKE.Solver_IN_ROOT_NODE_get();
  public static readonly int IN_SEARCH = operations_research_constraint_solverPINVOKE.Solver_IN_SEARCH_get();
  public static readonly int AT_SOLUTION = operations_research_constraint_solverPINVOKE.Solver_AT_SOLUTION_get();
  public static readonly int NO_MORE_SOLUTIONS = operations_research_constraint_solverPINVOKE.Solver_NO_MORE_SOLUTIONS_get();
  public static readonly int PROBLEM_INFEASIBLE = operations_research_constraint_solverPINVOKE.Solver_PROBLEM_INFEASIBLE_get();
 
  // OptimizationDirection 
  public static readonly int NOT_SET = operations_research_constraint_solverPINVOKE.Solver_NOT_SET_get();
  public static readonly int MAXIMIZATION = operations_research_constraint_solverPINVOKE.Solver_MAXIMIZATION_get();
  public static readonly int MINIMIZATION = operations_research_constraint_solverPINVOKE.Solver_MINIMIZATION_get();
 
}
 
}